This article explains Memcached’s architecture, key characteristics, suitable and unsuitable scenarios, memory management and LRU mechanisms, version details, and provides a comprehensive guide to monitoring its performance and health using Prometheus and Alibaba Cloud ARMS dashboards.
This article explains why Kubernetes pods get evicted, covering preemptive eviction, node‑pressure eviction, pod scheduling, priority classes, QoS tiers, alternative eviction methods, and how to monitor evictions with Prometheus, providing concrete commands and examples.
This guide explains how to enable OpenTelemetry in Apache Airflow, configure an OTel collector, use Prometheus as a metrics backend, set up Grafana dashboards, and visualize sample DAG metrics, providing a complete observability stack for Airflow pipelines.
Learn how to monitor Kubernetes CoreDNS using Prometheus by exposing its metrics endpoint, configuring scrape jobs, and tracking essential metrics such as build info, request latency, error rates, traffic volume, and cache performance to ensure DNS reliability and cluster health.
This article explains the fundamentals of metrics, introduces dimensional metrics, compares Prometheus, OpenMetrics, and OpenTelemetry standards, and provides detailed guidance on the four Prometheus metric types—Counters, Gauges, Histograms, and Summaries—including their use‑cases, PromQL queries, and Python client examples.
This article compiles a set of practical SpringBoot techniques, including Flyway-based SQL version control, JetCache declarative caching, Netty WebSocket service customization, jasypt configuration encryption, ShardingSphere data masking, Jackson response desensitization, read‑write splitting, idempotent request handling, MockMvc testing, and Prometheus‑Grafana monitoring.
This article explains how the automotive platform accelerated its cloud‑native service‑mesh transformation by integrating Opentelemetry, Prometheus, and Grafana, then details the configuration and practical use of Grafana's unified alerting module—including installation, data source setup, alert rule definition, contact points, message templates, and silencing—to achieve comprehensive observability and automated incident response.
This article describes how ZhaiZhai unified dozens of legacy monitoring tools into a single, all‑in‑one observability platform by adopting Prometheus + Grafana, extending the Prometheus client to push metrics to M3DB, automating Grafana dashboard creation, and building a custom alerting service to reduce operational complexity and improve visibility across business, middleware, and infrastructure services.
Explore nine indispensable Kubernetes tools—including Kubie, Kubespray, Helm, Minikube, K3s, Kustomize, KOps, Prometheus, and krew—that simplify cluster management, accelerate deployments, and enhance efficiency, helping you choose the right solution for smoother, more productive cloud‑native operations.
This article explains why Kubernetes pods are evicted, covering preemption, node‑pressure eviction, pod scheduling, priority classes, QoS tiers, other eviction methods, and how to monitor evictions with Prometheus, providing practical examples and command‑line snippets.
This article shares Huolala's experience designing a unified monitoring platform UI, covering the evolution from open‑source dashboards to a fully self‑developed solution, simplification of PromQL, computed metrics, log and trace integration, and the challenges of alert configuration and visualization.
This article introduces the fundamentals of metrics in IT monitoring, explains the structure of metric data points, explores dimensional metrics, and provides an in‑depth guide to Prometheus metric types—Counters, Gauges, Histograms, and Summaries—along with practical code examples and usage considerations in cloud‑native environments.
This article explains how metrics are used to monitor software performance, introduces basic metric components and dimensional metrics, compares Prometheus, OpenMetrics and OpenTelemetry standards, and provides detailed guidance on Prometheus metric types—Counter, Gauge, Histogram, and Summary—with code examples and query patterns.
This article details how Vivo's container platform faced exploding metric volumes, component overload, data gaps, and storage spikes, and explains the step‑by‑step architectural redesign, metric governance, performance tuning, cAdvisor redeployment, and VictoriaMetrics upgrade that restored high‑availability, low‑latency monitoring across a large Kubernetes fleet.
This article explains how KubeSkoop leverages eBPF to provide low‑overhead, pod‑level network monitoring and real‑time diagnostics for Kubernetes clusters, covering packet flow fundamentals, traditional troubleshooting tool limitations, the exporter’s probe architecture, daily monitoring practices, and future development plans.
Learn step‑by‑step how to set up Prometheus and Grafana with a Spring Boot 2.4.12 application, configure dependencies, expose metrics via Actuator, customize meters, and monitor database connection pools, providing a complete observability solution for Java backend services.
This guide demonstrates how to collect and store metrics, traces, and alerts in OpenObserve by configuring Prometheus remote_write, integrating OpenTelemetry SDKs and Collector, and setting up alert templates and destinations, complete with Kubernetes deployment examples, dashboard creation, and query techniques.
To give the business team a global, application‑level view of Pulsar performance, the team built a SkyWalking Java‑Agent plugin that automatically collects producer and consumer metrics from the Pulsar client, exposing latency, backlog and failure counts via Prometheus without modifying the client code.
This article explains how Prometheus stores alerts only as time‑series data, why that limits historical queries, and provides a complete open‑source solution using Alertmanager, Alertsnitch, MySQL, and Grafana to persist, query, and visualize alerts in production environments.
This guide explains how to design effective Prometheus metrics, choose appropriate monitoring objects, labels, and buckets, and leverage Grafana visualizations to gain deep insight into application performance across online services, offline processing, and batch jobs.
This article introduces Prometheus and Grafana, guides readers through setting up a monitoring environment for Alluxio—including installing and configuring Prometheus Server, Grafana, and Alluxio data sources—and explains manual dashboard tuning and data export techniques.
This tutorial explains how to use Docker to deploy DBLE, Prometheus, and Grafana, configure JMX Exporter for JVM metrics, and create a monitoring dashboard that visualizes CPU, memory pool, GC, and thread statistics of DBLE instances.
The vivo Internet Container Team built a scalable, high‑availability container monitoring platform by deploying dual‑replica Prometheus clusters with a custom HA adapter, remoteWrite to VictoriaMetrics, and a Kafka forwarder, while cutting metric cardinality, tuning cAdvisor, and upgrading VictoriaMetrics to eliminate data loss and storage spikes, achieving stable, efficient monitoring.
This article explains how to design a Prometheus‑based cloud‑native monitoring solution, covering target selection, metric collection, server configuration, Grafana visualization, and alert management with practical examples and code snippets.
This comprehensive guide explains Prometheus fundamentals, its ecosystem, metric collection models, configuration, PromQL querying, custom exporters, Grafana visualization, and Alertmanager setup, providing step‑by‑step instructions and code examples for effective system monitoring and alerting.
This article explains the mechanics of Kubernetes CPU resource limits, how to interpret limits as time slices, the Linux accounting system behind them, and which Prometheus metrics can be used to set proper limits and diagnose CPU throttling issues.
This guide explains how to set up Alibaba Cloud Observability Prometheus edition to monitor ClickHouse, covering ClickHouse fundamentals, metric collection, dashboard templates, alert rules, troubleshooting steps, and deployment options for both ACK and ECS environments.
This tutorial explains Prometheus service discovery types, why automatic discovery is essential, the scrape lifecycle, and provides step‑by‑step demos of file‑based discovery, Consul registration via Docker‑Compose, JSON API, and command‑line methods with full configuration examples.
This article explains performance monitoring concepts, lists essential metrics such as response time and CPU utilization, introduces popular monitoring tools like Prometheus and New Relic, and outlines a step‑by‑step process for selecting, configuring, visualizing, alerting, and continuously improving system performance.
The author reflects on the shortcomings of current logging, metrics, and tracing practices, explains why they become costly and unscalable, and offers concrete recommendations—including log level discipline, structured logging, metric aggregation, and the use of tools like Prometheus, Cortex, and Thanos—to build a more efficient observability stack.
OpenAI’s engineering team details how they expanded a Kubernetes cluster to 7,500 nodes to support massive models like GPT‑3, CLIP, and DALL·E, describing workload characteristics, networking redesign, API server pressure, monitoring, health checks, resource quotas, and the remaining open problems.
This guide walks through essential Redis operations, covering real‑time monitoring with the INFO command and Prometheus‑compatible exporters, data migration using Redis‑shake, consistency verification via Redis‑full‑check, and comprehensive cluster management with CacheCloud, providing practical tools for reliable Redis administration.
This article explains how to design effective Prometheus metrics for various application types, covering golden metrics, label selection, naming conventions, bucket choices, and Grafana visualization tips to help engineers build reliable observability solutions.
This article explains how Kubernetes resource limits function, how to interpret CPU limits as time slices, the Linux accounting system behind them, relevant Prometheus metrics for detecting throttling, practical examples with multithreaded containers, and guidance on setting alerts and avoiding performance pitfalls.
This article explores the limitations of a Prometheus‑based monitoring stack and demonstrates how adopting a Thanos‑based architecture improves metric retention, enables multi‑cluster querying, and reduces overall infrastructure costs while providing a scalable, cloud‑native solution.
Robusta KRR is a local CLI tool that gathers pod metrics from Prometheus, recommends CPU and memory requests and limits, supports custom strategies, and can be installed via Homebrew or source, helping Kubernetes clusters cut up to 69% of cloud costs.
This guide explains how to combine Kubernetes and Spring Boot to implement zero‑downtime releases by configuring readiness and liveness probes, defining graceful shutdown, applying rolling update strategies, setting up horizontal pod autoscaling, integrating Prometheus monitoring, and separating configuration via ConfigMaps for reusable images.
This article compares three leading time‑series databases—InfluxDB, Kdb+, and Prometheus—detailing their origins, core features, strengths, and drawbacks, and helps readers decide which solution best fits specific monitoring, IoT, or financial data workloads.
This guide explains how to enable Prometheus metrics on GitLab Runner, configure the runner’s HTTP endpoint, collect the metrics with Prometheus, and visualize both runner and CI pipeline data in Grafana using ready‑made dashboards.
This article explains how to set up Redis monitoring using Prometheus, covering installation of Redis Exporter, Prometheus configuration, Grafana visualization, and alert rule creation, providing step‑by‑step commands and guidance to ensure high availability and performance of Redis instances.
The article explains that high metric cardinality in Prometheus causes long query times and timeouts, and demonstrates how using recording rules to pre‑compute aggregates dramatically reduces cardinality and latency, while recommending scrape interval tuning and metric design best practices to keep charts responsive.
This article explains how to design and implement a lightweight, flexible monitoring solution for big‑data components running on Kubernetes using kube‑prometheus, covering metric exposure methods, scrape configurations, alert rule design, exporter deployment, and practical examples with code snippets.
This guide explains how to monitor Docker containers using the open‑source cAdvisor tool, integrate its metrics with Prometheus, and visualize the data in Grafana, providing step‑by‑step commands and configuration examples for a complete container‑monitoring solution.
Categraf is an all‑in‑one, Go‑based monitoring agent that consolidates metric, log, and trace collection, offering remote_write support, lightweight deployment, and extensive plugin configurations to replace multiple exporters in Prometheus‑based observability stacks.
This article reviews several popular open‑source monitoring tools—Cacti, Nagios, Zabbix, Prometheus, Grafana, Nightingale, and Open‑Falcon—detailing their core features, data collection methods, visualization capabilities, and typical use cases for IT operations.
This tutorial explains how to install the MySQL Exporter, configure Prometheus to scrape MySQL metrics, set up Grafana dashboards for visualization, and define alerting rules, providing a complete end‑to‑end solution for monitoring MySQL databases in production environments.
This guide explains how to achieve zero‑downtime releases of a Spring Boot application on Kubernetes by configuring readiness/liveness probes, rolling‑update strategies, graceful shutdown, horizontal pod autoscaling, Prometheus metrics collection, and externalized configuration via ConfigMaps.
This article explains why native Prometheus HA solutions fall short for large, multi‑region clusters and shows how to use Thanos components—including sidecar, query, store gateway, and compactor—to achieve long‑term storage, unlimited scaling, a global view, and non‑intrusive integration with existing Prometheus deployments.
This article explains how Prometheus can be used to monitor custom thread‑pool metrics in a Spring Boot backend, detailing configuration, dynamic parameter updates via Apollo, code examples for metric registration, and visualization and alerting with Grafana.
This tutorial shows how to enable Nginx's stub_status module, install the Nginx Prometheus Exporter, configure Prometheus to scrape Nginx metrics, and visualize the data in Grafana, providing a complete end‑to‑end monitoring solution.
This article details Qunar's migration from Prometheus to VictoriaMetrics for large‑scale container monitoring, covering the shortcomings of Prometheus at massive data volumes, the architectural choices made, performance improvements achieved, and future optimization plans.
This article explains what logs are, when to record them, their value in large-scale systems, and how to build effective log‑management and observability platforms using APM concepts, including metrics, tracing, ELK, Prometheus, and custom tooling for distributed architectures.
This article explains what logs are, when to record them, their value in large‑scale architectures, and how to build effective logging, metrics, and tracing platforms using tools such as ELK, Prometheus, and SkyWalking, while also presenting good and bad logging practices and sample batch‑log retrieval code.
This article explains Prometheus fundamentals, compares long‑term storage options, details Huolala's challenges with multiple Prometheus clusters, and introduces SHANGFU—a three‑module system that streamlines configuration, collection, and query handling to boost observability, performance, and reliability in cloud‑native environments.
An in‑depth comparison of Prometheus and Zabbix examines their histories, architectures, data storage, scalability, and container support, highlighting Prometheus’s cloud‑native pull model and Go‑based performance versus Zabbix’s mature, relational‑database approach, to help teams choose the right monitoring solution.
OpenYurt v1.2.0 streamlines edge‑native Kubernetes deployment by removing any modifications to native clusters, cutting the installation process from ten to five steps, and enabling seamless Prometheus monitoring through the new Raven VPN component while outlining future Helm‑based simplifications.
This article explains the internal storage layout, on‑disk and in‑memory data structures, and the query execution flow of Prometheus V2, illustrating how blocks, chunks, WAL, indexes and postings are organized and accessed to serve time‑series queries efficiently.
This article details how Huolala built a comprehensive full‑chain monitoring and tracing platform, covering the historical evolution of observability tools, the company’s multi‑stage monitoring architecture, bytecode‑enhanced instrumentation, trace sampling strategies, and a "what‑you‑see‑is‑what‑you‑get" visualization approach.
This article provides an in‑depth analysis of Prometheus V2's storage architecture, detailing the on‑disk block layout, chunk and index formats, the inverted index structure, memory representations, and the step‑by‑step query process that locates matching time‑series data.
This article explains the architecture of Prometheus V2, detailing its on‑disk block layout, chunk and index formats, the inverted index mechanism, and how queries locate and retrieve time‑series data, while also covering in‑memory structures and practical usage patterns.
This article guides readers through setting up a Kubernetes‑based ChatGPT bot using the open‑source Robusta platform, covering prerequisites, installation, Slack integration, configuration generation, Helm deployment, testing with crash pods, and interactive alert handling to streamline Prometheus alert resolution.
This article walks through installing Robusta, configuring Slack integration, adding Helm repositories, deploying the Robusta platform on a Kubernetes cluster, creating a crash‑loop pod to trigger alerts, and interacting with a ChatGPT bot to automatically troubleshoot Prometheus alerts, providing complete code snippets and screenshots for each step.
This article explains the principles behind Prometheus alerts, when they trigger, why they sometimes stay silent, and how Alertmanager’s routing tree and notification pipeline work together to manage alert noise, grouping, silencing, and deduplication.
The article examines logging’s critical role in distributed systems, detailing its purpose, severity levels, and value for debugging, performance, security, and auditing, while highlighting challenges of inconsistent formats and traceability, and reviewing observability pillars, ELK and tracing tools, and practical implementation best practices.
This article explains the fundamentals of metrics, the evolution of dimensional data, and provides a deep dive into Prometheus' four metric types—Counters, Gauges, Histograms, and Summaries—complete with practical code examples, query patterns, and a comparison of their strengths and trade‑offs.
This article explains how to combine Spring Boot with Micrometer, Prometheus, and Grafana for metrics collection and visualization, and provides Maven dependencies, configuration snippets, and Docker commands to deploy a fully monitored backend service using Docker containers.
This article explains when Prometheus alerts fire or stay silent, dives into the underlying alerting mechanics, sampling intervals, and the role of the for‑duration, then details Alertmanager's routing tree and notification pipeline that improve alert quality and delivery.
This article benchmarks Alibaba Cloud Prometheus against the open‑source Prometheus across multiple cluster sizes, churn rates, and query patterns, revealing that while the open‑source version remains stable under light load, its CPU and memory usage grow non‑linearly with high cardinality, whereas Alibaba's managed service delivers higher compatibility, better query performance, and more predictable scaling.
This article provides a comprehensive comparison between Zabbix and Prometheus, covering their architecture, data collection, storage, querying, visualization, and alerting capabilities to help enterprises choose the most suitable monitoring solution for their needs.
This guide explains why MySQL monitoring is critical, defines five key metric dimensions, shows how to collect them with Prometheus and the MySQL Exporter, provides ready‑to‑use alert rules, and walks through the full setup and dashboard creation on Alibaba Cloud.
The article explains how a sudden Go service memory‑usage alert was traced with go tool pprof to a massive allocation in the quantile.newStream function, uncovered a Prometheus metric‑label explosion caused by the START_POINT label, and resolved the leak by disabling that label, while also reviewing typical Go memory‑leak patterns.
This article explains how to design and implement a Prometheus‑based monitoring solution for big‑data components running on Kubernetes, covering metric exposure methods, scrape configurations, alerting architecture, exporter development, and practical code examples for a production‑ready setup.
This tutorial demonstrates how to add Micrometer to a Spring Boot project, configure JVM and custom metrics, expose them via Actuator, and then integrate Prometheus and Grafana to collect and visualize the monitoring data, providing a complete end‑to‑end observability solution.
This article analyzes common problems in a Prometheus‑Alertmanager monitoring setup—such as alert noise, lack of escalation, suppression and silence management—and presents a comprehensive refactor that introduces per‑cluster Alertmanager instances, custom escalation logic, suppression tables, and Python scripts to handle alert routing, silencing, and recovery.
This article explains how to design effective Prometheus metrics, choose appropriate vectors, labels, buckets, and naming conventions, and offers Grafana usage tricks to help engineers monitor online services, batch jobs, and offline processing systems with clear, actionable insights.
Prometheus is an open‑source monitoring solution that covers metric exposition, scraping, storage, querying, visualization, and alerting, and this guide walks through its architecture, configuration, custom exporters, PromQL queries, Grafana integration, and alert management, providing a comprehensive introduction for developers and ops engineers.
This guide explains how to collect essential Windows metrics with Prometheus, set up Grafana dashboards for CPU, memory, disk, network, and process monitoring, and configure alert rules, while also comparing self‑hosted and Alibaba Cloud Prometheus solutions for seamless Windows observability.
This article explains how to replace Zabbix with Prometheus for MySQL monitoring by configuring mysqld_exporter to collect metrics from multiple MySQL instances, details the required user accounts, shows common errors, and provides step‑by‑step solutions including building a newer exporter, adjusting configuration files, and using auth_module for password management.
This article details Qunar's migration from a Prometheus‑based monitoring stack to VictoriaMetrics, describing the limitations they faced, the architectural redesign using vmagent, vmcluster, and vmalert, and the resulting performance improvements and operational benefits for large‑scale Kubernetes environments.
This guide explains how to build a real‑time monitoring system for JMeter performance tests by integrating InfluxDB, Prometheus, and Grafana, deploying the stack with Docker‑Compose, and configuring JMeter’s Backend Listener to collect and visualize metrics continuously.
This article explains the motivations for selecting Grafana Loki instead of ELK/EFK, introduces its core concepts and features, provides step‑by‑step deployment instructions for Promtail and Loki, and demonstrates how to configure Grafana, query logs, and handle label indexing, dynamic tags, and high‑cardinality challenges.
This article explains how to use the Prometheus HTTP API to query instant and range metrics, interpret the JSON responses, and fetch data programmatically with Python, providing code examples and details on request parameters, error handling, and practical usage.
This article details Qunar’s migration from a traditional Prometheus‑based monitoring stack to VictoriaMetrics, describing the challenges of large‑scale container metrics collection, the architectural redesign using VM‑Cluster, vmagent, and vmalert, and the performance improvements achieved after full replacement.
Monitoring Kubernetes clusters is essential for visibility and scalability, but selecting the right tools can be complex; this article outlines best‑practice approaches and compares popular open‑source solutions such as Prometheus, Grafana, Thanos, Elasticsearch, Logstash, and Kibana, helping you build an effective monitoring stack.
This article describes how to replace Zabbix with Prometheus for MySQL monitoring by configuring mysqld_exporter to collect metrics from multiple MySQL instances, including environment setup, user creation, exporter configuration, troubleshooting common errors, and Prometheus job adjustments, providing step‑by‑step commands and code examples.
This article visually explains Prometheus’s architecture, core features, metric collection methods, exporters, PromQL query language, and alerting workflow, helping readers understand how to monitor cloud‑native systems effectively while noting its strengths and limitations.
This article explains how RocketMQ integrates with Prometheus and Grafana to provide comprehensive metrics, tracing, and logging, detailing the exporter architecture, deployment choices, span topology, dashboard examples, and ARMS‑based alerting for cloud‑native message‑queue observability.
Tencent transformed its popular Happy Dou Dizhu game’s monitoring by migrating to Tencent Cloud Managed Prometheus and Grafana, unifying metric naming, consolidating ServiceMonitors, defining dashboards as code, and avoiding high‑cardinality labels, which cut labor costs by over 30% and greatly improved operational efficiency.
This article provides a systematic overview of monitoring fundamentals, compares three popular open‑source monitoring solutions—Zabbix, Open‑Falcon, and Prometheus—and offers practical guidance for selecting the most suitable system based on scale, features, and operational needs.
This article explains the current state of cloud‑native alerting, introduces Grafana Mimir as a horizontally scalable, multi‑tenant storage for Prometheus, details its architecture and components, and provides step‑by‑step guidance for installing, configuring, and operating Mimir in Kubernetes environments.
This guide walks you through creating a complete observability stack—exporting metrics, traces, and logs from a Go web service, collecting them with OpenTelemetry Collector, and storing them in Grafana Mimir, Loki, and Tempo, then visualizing everything on a unified Grafana dashboard.
This guide explains why native cloud monitoring falls short, how building custom Prometheus exporters adds overhead, and how Alibaba Cloud's fully managed Prometheus service—through enterprise cloud‑monitoring and self‑monitoring integration modes—provides ready‑to‑use exporters, agents, Grafana dashboards, and alert templates for dozens of cloud products.
Learn how to use Prometheus's stable V1 API to query instant and range data, handle responses and errors, and fetch metrics programmatically with curl and Python, enabling data analysis, cost management, and advanced monitoring beyond basic alerts.
This article details the redesign of an internal monitoring system, explaining why the original zzmonitor fell short, how Prometheus and its ecosystem were selected, the architecture that integrates remote storage with M3DB, performance benchmarks, Grafana visualisation, and a custom alerting solution.
This article explains how Grafana Mimir provides a scalable, highly‑available, multi‑tenant long‑term storage for Prometheus, details its architecture and core components such as compactor, distributor, ingester, querier, query‑frontend and store‑gateway, and shows step‑by‑step installation, status checking, and Alertmanager configuration for cloud‑native environments.
This article systematically introduces monitoring fundamentals, explains the architecture and key metrics of typical monitoring objects, compares three popular open‑source monitoring solutions—Zabbix, Open‑Falcon, and Prometheus—and provides practical guidance for selecting the most suitable system.
This article explains how to design and implement a Prometheus‑based monitoring system for big‑data components running on Kubernetes, covering metric exposure methods, scrape configurations, exporter deployment, and dynamic alert rule management with Alertmanager.
This guide explains how to use Alibaba Cloud's fully managed Prometheus service to collect and visualize metrics from ECS‑based applications across pure VPC, hybrid VPC‑IDC, and multi‑cloud scenarios, detailing the pain points of self‑built solutions and providing step‑by‑step configuration instructions.
This article introduces five popular open‑source network monitoring solutions—Cacti, Nagios Core, Icinga 2, Zabbix, and Prometheus—explaining their main features, data collection methods, platform support, and typical use cases to help administrators choose the right tool for reliable system oversight.
This article details the design and implementation of a three‑dimensional monitoring system that replaces an outdated custom solution with Prometheus, M3DB remote storage, and Grafana, covering data model choices, metric types, architecture, performance testing, automatic dashboard generation, and a custom alerting service.
