DEV Community: Marko Krstic

DockStats: Lightweight Docker Monitoring for Logs and Metrics

Marko Krstic — Sat, 21 Jun 2025 10:43:18 +0000

In the world of modern software development, where agility and scalability rule, Docker has become a cornerstone technology. It enables developers to package applications and dependencies into containers that can run anywhere, from local development environments to vast production clusters. But as helpful as Docker is for deployment, it poses a challenge for monitoring and observability, especially for teams managing multiple containers across several hosts.

That’s where DockStats steps in.

What is DockStats?

DockStats is a lightweight yet powerful monitoring platform built for developers and teams who run Docker containers in production. It provides real-time access to logs and system metrics from all Docker containers across all your hosts, all in one centralized dashboard. Whether you deploy applications on a single machine or manage multiple Docker hosts, DockStats makes it easy to keep tabs on everything.

Unlike many traditional monitoring tools that are often bulky, expensive, or designed for Kubernetes-heavy environments, DockStats is specifically engineered for simplicity, efficiency, and flexibility. It was created with a clear focus: empower developers with deep visibility into their Dockerized infrastructure without introducing unnecessary complexity.

Why Monitoring Docker is Hard

Monitoring Docker isn't always straightforward. Containers can start and stop quickly, and when they do, their logs often disappear. Tracking performance and usage across different hosts can be complicated and usually involves using several tools with complex setup steps. For developers who want simple and reliable observability, this quickly becomes frustrating.

Common Challenges:

Short-lived containers: Logs and data vanish when containers stop.
Multiple hosts: It's tough to gather everything in one place.
Too many tools: Often need separate solutions for logs, metrics, and alerts.
Complicated setup: Many tools require lots of configuration to get started.

DockStats to the Rescue

DockStats tackles these challenges with a minimalistic yet effective approach:

Easy Integration

Just run the DockStats Agent on any Docker host. That’s it. The agent automatically detects all running containers and starts collecting logs and metrics without the need for manual configuration. It works seamlessly in any Docker environment.

Centralized Dashboard

All collected data is sent to the DockStats Hub — your unified monitoring interface. No matter how many hosts or containers you have, everything is aggregated and displayed in one place. You get a holistic view of your system.

Secure and Lightweight

The agent is built to be lightweight and efficient, so it doesn’t burden your system resources. All data is encrypted in transit. If you choose the cloud version, nothing is stored locally — logs and metrics stream securely to the cloud dashboard.

Cloud or Self-Hosted Options

DockStats offers complete flexibility. Use the fully managed cloud platform, or deploy DockStats Hub on your own infrastructure. This dual model makes DockStats suitable for both startups and enterprises with strict compliance requirements.

Key Features of DockStats

Let’s dig deeper into what makes DockStats such a powerful tool for Docker observability.

1. Automatic Log Collection

As soon as the DockStats Agent is running, it begins collecting logs from all containers on that host. No need to modify container definitions or volumes. It understands the Docker runtime and hooks into the right places.

Logs are aggregated and made available for search and filtering through the central dashboard. This means that even if you have containers running on 10 different VMs, all their logs are unified.

2. Log Classification and Filtering

DockStats organizes logs by:

Log level (INFO, WARN, ERROR, etc.)
Application name
Environment (e.g., production, staging)

You can also search and filter logs by message content or custom fields embedded in structured logs (e.g., JSON-formatted logs). This makes it easy to pinpoint issues or track behavior across your microservices.

3. Basic Log Analytics

DockStats gives you a visual understanding of log activity over time. Spot spikes in errors, identify unusual patterns, or analyze trends in system output. This is especially helpful for post-mortems or understanding cascading failures.

4. Host and Container Metrics

On the metrics side, DockStats monitors:

Host-level resources: CPU, memory, disk, etc.
Per-container metrics: CPU and memory usage per container, no matter which host it's on.

This level of granularity helps you understand how each container behaves and how it contributes to overall system load.

5. Alerts and Thresholds

Get notified when things go wrong. DockStats lets you set alerts for key resource thresholds (e.g., container CPU usage exceeds 80%, memory usage above 90%). This way, you can react before your application crashes or slows down.

Use Cases

DevOps Monitoring

Track and monitor Docker containers in real-time across environments. Whether it’s dev, staging, or production, you’ll always know what’s happening inside your containers.

Incident Response

Use DockStats to dig into logs during outages, pinpoint the root cause, and correlate metrics with application behavior.

Performance Optimization

Spot resource-hungry containers or inefficient memory usage. Use this insight to optimize your infrastructure.

Audit and Compliance

If you're in a regulated industry, having a complete log trail across all containers is vital. DockStats gives you that historical record.

The Architecture Behind DockStats

DockStats is composed of two core components:

DockStats Agent

A small, efficient binary that runs on each Docker host. It:

Detects all containers on the host
Streams logs and metrics
Requires no extra setup

DockStats Hub

The central dashboard that ingests and visualizes all data. You can use:

The cloud-hosted version (fast and managed for you)
The self-hosted version (for full control and data privacy)

Designed for Developers

Many monitoring tools are built for IT Ops teams and come with a steep learning curve. DockStats is different. It’s built with the developer experience in mind:

Easy to set up
Works out of the box
No vendor lock-in
Clear, clean UI
Affordable pricing (and free tier for small teams)

Summary

Observability shouldn't be a luxury reserved for large enterprises or Kubernetes-native applications. With DockStats, developers finally get a tool that is lightweight, powerful, and tailored for monitoring Docker containers in production.

If you’re tired of cobbling together logs, metrics, and alerts from three or more different systems, give DockStats a try. It could be the missing piece in your DevOps toolkit.

Learn more or sign up at dockstats.com

From Freelance to Founder: The Simple Rules That Keep Clients Coming Back

Marko Krstic — Fri, 13 Jun 2025 08:51:55 +0000

In a world full of freelancers, agencies, and tech startups, standing out isn’t about having the flashiest portfolio or charging the highest rates. Often, it comes down to something much simpler: reliability, honesty, and consistent communication. I’m currently a freelance developer working toward the long-term goal of building a successful development company. So far, I haven’t lost a single client — and I intend to keep it that way.

How? I follow four core principles that have helped me deliver exceptional results, build lasting client relationships, and create a reputation strong enough to fuel growth. They’re not groundbreaking, but they are effective. This blog post dives into each one, explains why they matter, and explores how any freelancer or aspiring entrepreneur can adopt them to build a solid foundation for long-term success.

1. Always Overdeliver: Underpromise, Overdeliver

"Never promise more than you can do; it's better to promise less and deliver more."

Overdelivering isn’t about working yourself to the bone for free. It’s about creating a margin of excellence in your client’s mind. When you deliver more than what was agreed upon, you create delight. Clients don’t just feel satisfied — they feel impressed.

Why This Works:

Expectation management: When you underpromise (without compromising on value), you leave room to exceed expectations.
Trust builder: Overdelivering shows you're invested in the project, not just the paycheck.
Marketing advantage: Happy clients become advocates. They refer you, promote you, and come back with more work.

How to Overdeliver Without Burning Out:

Add a simple extra feature or functionality that wasn’t scoped but adds clear value.
Provide documentation, user guides, or videos that go beyond what was expected.
Anticipate problems before the client notices them and offer solutions proactively.
Deliver ahead of schedule when possible.

Overdelivering shouldn’t become the norm that you get taken advantage of — it should be a deliberate strategy to make your work memorable.

2. Radical Honesty: Own Every Mistake

"Always be honest. Never lie. Even if you make a mistake, admit it. That builds trust."

It sounds simple, but radical honesty is rare. Most people instinctively try to cover up mistakes, shift blame, or justify errors. But in client relationships, trust is everything. The minute a client senses you’re hiding something, the relationship deteriorates.

Why This Works:

Transparency is refreshing: It sets you apart in a market where many overhype their capabilities.
Trust breeds loyalty: Clients who trust you are more likely to be patient, collaborative, and understanding.
Mistakes are inevitable: Owning them turns problems into opportunities for growth and better systems.

How to Practice Radical Honesty:

If you make a mistake, tell the client immediately, explain what went wrong, and propose a solution.
If you’re uncertain about a request or technology, say so. Then offer to research or bring in someone who knows.
Avoid vague updates. Be clear about setbacks, delays, or roadblocks.

Your honesty is your reputation. Long-term business success isn’t built on perfection, but on trust.

3. Be Unshakably Reliable: Deadlines Are Sacred

"Always be on time and never miss a deadline."

In freelance work, your word is your bond. You don’t have a massive brand backing you or a big-name agency on your resume. What you do have is the power to show up exactly when you say you will and deliver exactly what you promised.

Why This Works:

Deadlines reduce uncertainty: When clients know you’re dependable, they stop micromanaging.
Reliability scales: As you build a team or grow your business, the same discipline creates a culture of punctuality.
Most freelancers flake: Being reliable automatically puts you in the top tier.

How to Maintain Deadline Discipline:

Scope your work accurately and always include buffers.
Break the project into smaller deliverables with internal milestones.
Use tools like Trello, Notion, or Asana to keep track of progress.
Say no when your schedule is full. Overcommitting is the enemy of reliability.

One missed deadline can erase months of goodwill. Being known as someone who always delivers on time is a competitive edge few people take seriously enough.

4. Communicate Early, Communicate Often

"If the client is asking 'how is the project going?', you’re already behind."

Communication is one of the most underrated aspects of client service. You might be doing brilliant work behind the scenes, but if your client doesn’t hear from you, their confidence starts to erode.

Why This Works:

Reduces anxiety: Regular updates keep clients relaxed and engaged.
Eliminates surprises: Issues caught early are easier to fix.
Builds a narrative: Frequent communication creates a story of progress that the client can follow and share.

How to Communicate Well:

Schedule weekly check-ins via Zoom or Slack.
Send progress summaries after major milestones.
Proactively inform clients of changes, risks, or delays.
Ask for feedback early and often, not just at the end.

Good communication is the glue that holds projects together. Great communication is the reason clients come back.

The Compound Effect: What Happens When You Apply All Four

Individually, these rules create trust, efficiency, and satisfaction. Together, they create a reputation. Clients don’t just see you as a contractor; they see you as a partner. That’s the difference between someone who gets one-off gigs and someone who builds a business with long-term clients, referrals, and growth opportunities.

Here’s what happens when you stick to these rules:

You stop competing on price. Clients are happy to pay a premium for peace of mind.
You get consistent referrals. Word-of-mouth becomes your best marketing.
You build long-term partnerships. Repeat business means fewer sales calls and more time doing actual work.
You create a foundation for scaling. When it’s time to hire or start an agency, you already have clients who trust you to lead a team.

Building a Dev Company: Why These Rules Matter Even More at Scale

As I work toward turning my freelance work into a development company, these rules aren’t changing. They’re becoming even more essential.

When I hire, I’ll look for people who embody the same principles.
When I build processes, they’ll be designed around trust, communication, and delivery.
When I market the company, our brand will stand for reliability and transparency.

Clients don’t care if you’re a solo freelancer or a 10-person team. They care about outcomes, communication, and whether they can sleep at night knowing their project is in good hands.

Success Doesn’t Have to Be Complicated

A lot of people overcomplicate freelancing and business-building. They chase hacks, trends, and tools. But if you focus on doing the basics well — overdelivering, being honest, meeting deadlines, and communicating consistently — you’ll be ahead of 90% of the field.

Clients remember how you made them feel. If they felt confident, informed, respected, and impressed, they’ll never forget you. And they’ll never leave.

That’s how I’ve kept 100% of my clients so far. And that’s how I plan to keep growing from freelancer to founder.

About Me
I'm a freelance developer and founder of Cyberoutput — a dev company in the making focused on delivering high-quality software with clarity and precision. I'm also building DockStats, a tool for aggregating Docker logs and metrics to make container monitoring easier and more efficient.

If you're curious about my work or want to collaborate, feel free to explore either platform.

Why Golang Is Such a Powerful Language

Marko Krstic — Mon, 02 Jun 2025 12:00:53 +0000

When I first started learning Go (or Golang), I didn’t expect much. It looked very simple, maybe even too simple. But after spending time with it and building real projects, I realized that this simplicity is actually what makes Go so powerful. In this blog post, I’ll try to explain why Go is such a great programming language, especially for people who want to build solid, fast, and reliable software.

Simplicity Is Power

Go is very easy to learn. The syntax is small, and you can understand most of it in a day or two. You don’t need to learn a huge number of features to be productive. There are no crazy complex patterns, and you won’t find tons of hidden magic. What you write is what you get.

This simplicity helps teams move faster. Everyone understands the code easily. There are fewer bugs because there is less complexity. And when there are bugs, they are easier to find and fix.

Explicit Code Wins

In Go, everything is very explicit. You see what the code is doing. There is no guessing. This might feel a bit annoying at first because you have to write a little more, but in the long run, it pays off. It makes reading and understanding code much easier, especially for new developers joining the project.

Great Standard Library

Go comes with a very clean and powerful standard library. It doesn’t have everything, but what it does have works very well. You can write a web server, handle JSON, work with files, deal with networking, and more – all with the standard library.

Because the library is not bloated, it’s also easier to learn. You don’t have to remember hundreds of packages. You focus on what matters.

Concurrency Made Easy

Concurrency is the ability to run many things at the same time. It’s super important for modern software, especially when building servers or systems that do a lot of things at once.

Go has something called goroutines and channels. They make concurrency very simple and safe. Instead of dealing with threads and locks, you use goroutines to run tasks and channels to communicate between them.

This is one of the biggest reasons people love Go. You can write fast, scalable programs without a lot of pain.

Easy to Learn and Use

Many developers say that Go is boring. But that’s a good thing! Boring means stable, predictable, and safe. It means fewer surprises and more time to focus on building your app.

If you’re coming from languages like JavaScript, Python, or Java, you will find Go very refreshing. It doesn’t try to be clever. It just works.

Popularity and Job Market

Go is very popular right now. Big companies use it, and many startups love it too. It’s especially popular for backend systems, cloud tools, and microservices.

Because of this, there are lots of job opportunities for Go developers. And since the language is so efficient and simple, companies can move fast and hire Go devs who can get things done.

Famous Tools Written in Go

A lot of very powerful and popular tools are written in Go. This shows that Go is not just a toy language. It’s used for serious stuff. Here are a few of them:

Kubernetes (k8s)

Kubernetes is a system for managing containers. It helps you run apps across many servers. It handles scaling, failover, and more. It’s used by big tech companies and is one of the most important cloud tools today. Written in Go.

Docker

Docker is a tool that lets you package apps into containers. These containers run anywhere. It changed how we deploy software. The core of Docker is written in Go.

Terraform

Terraform is used to manage infrastructure. You can define your servers, databases, and networks in code, and Terraform will create them for you. It’s like DevOps magic. Written in Go.

Prometheus

Prometheus is a monitoring system. It collects metrics from your apps and systems and lets you alert when something goes wrong. It’s also written in Go and is part of the Cloud Native stack.

Dockstats

DockStats is a tool for monitoring Docker containers. It has a hub and agents, and it helps track what containers are doing. It’s written in Go and is easy to use. A nice feature is that it collects logs and metrics from many hosts and puts them all in one place.

Go Makes You a Better Developer

Because Go doesn’t have a lot of "magic," you end up learning a lot about how things really work. You understand how to design software. You learn how to handle errors, how to test code, and how to think in a simple way.

Go helps you focus on real engineering. Not on tools or frameworks.

It's Not All Perfect, But That's Okay

Go is not perfect. Sometimes it can feel too simple. Generics were missing for a long time (they were added recently). Error handling is a bit repetitive. But even with these flaws, Go gets the job done. And the simplicity often turns out to be an advantage, not a downside.

Final Thoughts

Go is a great language for building real-world software. It’s simple, fast, and powerful. It makes it easy to write code that is easy to understand, maintain, and scale. Many of the most important tools in the cloud-native world are written in Go.

If you’re thinking about learning Go or using it for your next project, I highly recommend it. It might feel strange at first, but once you get used to it, you’ll see why so many developers love it.

Go is not just another language. It’s a tool that helps you build amazing software, stay productive, and grow as a developer.

Centralized Logging for Docker: What Are Your Options?

Marko Krstic — Wed, 28 May 2025 07:58:18 +0000

When you run a lot of Docker containers, it can be hard to see what is going on. Each container writes logs and these logs might be important. They help you know if something is broken. They also help you understand how your app is working.

But logs from many containers on many servers? That can get messy. This is why people use centralized logging. Centralized logging means all logs go to one place so that you can look at them easily.

In this post, we will talk about how to collect logs from Docker. We will see what tools people use. And we will look at the pros and cons of each.

Why Logs Matter

Logs are like notes that your app writes. These notes say what the app is doing. If the app crashes, the logs can tell you why. If users have problems, the logs help you understand them.

Without logs, fixing bugs is like guessing. Logs are your flashlight in the dark.

How Docker Logs Work

Docker containers run apps. These apps write logs. By default, Docker collects these logs. You can see them with:

docker logs <container-name>

But this only works for one container at a time. If you have 10 containers, you must run the command 10 times. Not fun.

Also, if your container crashes and restarts, old logs may be gone. So we need a better way.

Centralized Logging

Centralized logging means you collect all logs from all containers. You send them to one place and this place stores the logs. It shows you the logs in a nice way.

There are many tools for this. Let’s look at some of them.

1. ELK Stack (Elasticsearch, Logstash, Kibana)

🔗 ELK Stack

The ELK Stack is a popular open-source solution for log management.
Logstash collects and processes logs from different sources, and sends them to Elasticsearch. Elasticsearch stores and indexes the data so you can search it quickly. Kibana lets you view and explore the logs in a dashboard. It’s powerful, but setting it up and running it can be heavy on resources and hard to manage.

Pros:

Powerful query and search capabilities.
Tons of community support and documentation.
Kibana has rich visualizations.

Cons:

Complex to deploy and maintain.
High resource usage (RAM, CPU, disk).
Too complex for small apps.

Best for: Big teams with time to manage it.

2. Loki + Promtail + Grafana

🔗 Loki

Loki is a log aggregation system made by the creators of Grafana. Promtail is the agent that collects logs from files or containers and sends them to Loki. Grafana is used to search and visualize the logs. It’s much lighter than ELK and easy to use if you already work with Grafana. Loki works best with Grafana — using it without Grafana is possible, but not ideal.

Pros:

Easier than ELK.
Uses less memory.
Works well with Prometheus.

Cons:

Less powerful than ELK.
Needs many pieces to work.

Best for: People who already use Grafana.

3. Graylog

🔗 Graylog

Graylog is a log management tool that works with structured and unstructured logs. You can collect logs from Docker using the GELF log driver or tools like Filebeat. It stores and indexes the logs so you can search and filter them later. Graylog can be self-hosted for free, or used as a managed cloud service if you want. Setup is flexible but might need more steps compared to simpler tools.

Pros:

Clean UI.
Easy to use search.
More user-friendly than raw ELK

Cons:

Still needs Elasticsearch.
Scaling can get complex.
Not super light.

Best for: Teams who want ELK but easier.

4. DockStats

🔗 DockStats

DockStats is a lightweight, and probably the simplest, cloud-based platform made for Docker users. You install a small agent on your servers, and it collects logs and system metrics. The data is sent securely to the DockStats dashboard where you can search and filter it. There's no need for complex setup — just one agent and you're ready to go.

Pros:

No configuration needed — plug and play
Collects logs from all Docker containers.
Logs and metrics in one place.

Cons:

Still new, many features still coming.
Small but growing community

Best for: Developers who run Docker without Kubernetes. Especially if you self-host everything.

What Should You Use?

It really depends on what you need and how much time and energy you want to spend.

If you want something powerful and flexible, and you don’t mind a complex setup, the ELK Stack is a strong choice. But be ready to deal with memory usage, configuration files, and maybe even a full-time person to manage it.

If you already use Grafana and like simple tools, then Loki + Promtail might be perfect. It’s easier to run than ELK, and it works well for most use cases. But keep in mind, it’s mainly built for Grafana, so if you don’t use Grafana, it might feel limited.

If you like to customize everything and want a mix of open-source and enterprise features, Graylog could work. It gives you a lot of control and different ways to collect logs. But again, setup can take some time, especially if you're new to it.

If you're self-hosting apps in Docker and just want something quick, easy, and made for developers, DockStats is worth trying. You just drop in one agent, and you get a clean dashboard for logs and metrics, without having to manage big systems or deal with Elasticsearch. It’s also a nice fit if you're running many small servers and want everything in one place without stress.

There’s no one-size-fits-all, but now you have a better idea of what each tool does — so pick the one that feels right for your project. ✅

Final Words

Logs are important. If you run Docker apps, logs help you stay in control.

Start with something simple. You can always change later.

Happy logging! 🐳