Disk Usage Alerts Need Warning and Critical Bands
A single disk threshold gives operators no distinction between early cleanup work and a filesystem that is close to stopping writes.
capacity
Label Freedom Comes With a Time-Series Cost
Metric labels let us divide one measurement in many useful ways, but every new combination of label values can create another time series. Greater detail also carries collection, storage, and query cost.
Container Running, Healthy and Useful Are Three Different States
A production-engineering deep dive into container running, healthy and useful are three different states, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
How cAdvisor Became One of My Largest Workloads
A production-engineering deep dive into how cadvisor became one of my largest workloads, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
Inode Exhaustion Can Break a Filesystem with Free Gigabytes
Free-space graphs can remain green while a workload creates huge numbers of tiny files and consumes the available inode table.
CPU by Container Is Useful Only Beside Limits
A container using one full CPU may be expected on an unrestricted worker and catastrophic for a service capped at a fraction of a core.
FreeSWITCH Capacity Testing Needed More Than a Calls-Per-Second Number
Call setup rate, concurrent calls and media work stress different parts of a voice platform.
The Monitoring Stack Needs a Memory Budget Too
Observability was becoming one of the larger workloads on a small production server, which is dangerous when monitoring competes with the services it protects.
Swap Usage Needs Duration and Context
A few megabytes of swap on an old Linux host did not automatically mean an incident, especially after long uptime.
Metric Cardinality Is a Capacity Problem Disguised as a Naming Problem
Labels make dashboards flexible, but uncontrolled label values multiply time series and memory cost quickly.
How I Took cAdvisor from ~428 MiB to ~20–28 MiB
A production-engineering deep dive into how i took cadvisor from ~428 mib to ~20–28 mib, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
What Do We Lose When We Do Not Keep Every Trace?
Keeping a complete trace for every request can be expensive. Sampling controls that cost, but it also defines what an investigation can and cannot see. A missing trace is not evidence that the event never happened.
A Docker Storage Cache Needs Its Own Freshness Metric
A production-engineering deep dive into a docker storage cache needs its own freshness metric, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
Airtime Is a Budget Too
A sensor message may contain only a few bytes, but many sensors can share the same radio medium. The important question is not only how much data exists, but how long each transmission occupies that shared medium.
Restart Counts Without Context Create Noise
A production-engineering deep dive into restart counts without context create noise, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
Prometheus Series Count Is an Observability Capacity Metric
The hserver stack carried roughly twenty-seven thousand active Prometheus series, enough that label growth and exporter changes could materially change memory and storage cost.
PostgreSQL Connection Utilization Needs a Denominator
A count of sixty active PostgreSQL connections is meaningless until it is compared with the configured maximum for that server.
Memory Limit Utilization vs Working Set: Which One Should Page Me?
A production-engineering deep dive into memory limit utilization vs working set: which one should page me?, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
OOM Events Are Better Evidence Than “High Memory” Alone
A production-engineering deep dive into oom events are better evidence than “high memory” alone, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
FreeSWITCH Health Is a Fleet Count, Not One Boolean
A multi-worker voice stack can keep serving calls after one FreeSWITCH node fails, so one global up/down flag hides degraded capacity.
Volume Size Monitoring Needs Ownership Context
A large Docker volume is not actionable if the dashboard cannot tell which service owns it or whether that growth is expected.
Changing Codecs Changes the Work Behind the Audio
If a codec is treated as nothing more than an audio format, a large part of the cost inside a phone system stays hidden. When two sides cannot use the same codec, audio may need to be decoded and encoded again in the middle.
When You Widen a Channel, Who Are You Sharing the Spectrum With?
Wider channels suggest higher speed, but nearby networks still occupy the same radio environment. Increasing your own peak capacity and getting stable performance in that environment are not the same design decision.
Socket Counts Are Capacity Clues, Not Health by Themselves
A rising established-connection count can represent normal load, a leak, slow clients or a downstream dependency holding sockets open.
Docker Filesystem Scanning Was More Expensive Than the Metric Was Worth
A production-engineering deep dive into docker filesystem scanning was more expensive than the metric was worth, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
Container Block I/O and I/O Pressure Tell Different Stories
A production-engineering deep dive into container block i/o and i/o pressure tell different stories, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
Image Storage Growth Is Different from Runtime Data Growth
Docker images can quietly accumulate through repeated deployments even when application volumes and databases remain stable.
Monitoring Tax: Why Exporters Need Resource Budgets
A production-engineering deep dive into monitoring tax: why exporters need resource budgets, grounded in the 2014 Mac mini hserver observability stack and its accepted runtime evidence.
A Growing Queue Is Growing Work Debt
Queues let producers and workers move at different speeds for a while, but a queue that keeps growing is accumulating work debt against the future. More waiting space does not create more processing capacity.