This article explains how to create a custom compile‑time annotation processor that automatically injects the current JAR version into Java component constants, eliminating manual updates and enabling Prometheus monitoring of version usage across internal libraries.
This article explains the concept of observability, details Prometheus metric definitions and types, and provides Go code examples for exposing, defining, generating, and scraping business‑level metrics in a Kubernetes‑based cloud‑native environment.
This guide explains how to enable Nginx's stub_status module, install and run the Nginx Prometheus Exporter, configure Prometheus to scrape Nginx metrics, and visualize the data using Grafana, providing a complete monitoring solution for web services.
This article explains how to create a compile‑time annotation processor that automatically injects the JAR version into a static constant, enabling Prometheus to monitor version usage without manual updates, and demonstrates the implementation with Lombok‑style code examples.
This article explains the background of metrics in cloud‑native systems, shows how to expose custom Prometheus metrics using OpenTelemetry's MeterProvider, compares different exporters, and provides a complete Pulsar client example with code snippets and configuration for end‑to‑end observability.
This article explains how enterprises can use Alibaba Cloud's ACK One platform together with the Prometheus‑based Observability service to build a unified, cloud‑native monitoring solution for heterogeneous, multi‑region Kubernetes clusters, addressing scalability, cost, and operational challenges.
This article demonstrates how to create a custom compile‑time annotation processor that automatically injects the JAR version into Java constants, enabling Prometheus monitoring of component versions without manual updates, and walks through the full implementation, registration, and testing steps.
This article demonstrates how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants at compile time, enabling Prometheus monitoring of version usage without manual updates.
This article introduces Karma, a Docker‑deployed Prometheus alert dashboard that aggregates multiple Alertmanager instances, explains its installation requirements, and details key features such as visual alert aggregation, tag‑based grouping, and silence management, positioning it as a valuable operations tool.
This guide walks you through configuring Prometheus alerting, using Alertmanager’s grouping, inhibition and silencing features, and integrating alerts with Enterprise WeChat via Docker, Docker‑Compose, and custom YAML and template files, complete with verification steps and sample CPU/memory rules.
The article analyzes why Prometheus sometimes returns inaccurate metric values, revealing the design trade‑offs that favor efficiency over precision, and walks through common pitfalls in rate/increase calculations, histogram P99 estimation, and practical recommendations for choosing scrape intervals and query windows.
Prometheus, a leading monitoring system, can achieve high availability through several common architectures—including dual-node with external storage, federated mode with external storage, and multi-node clusters combined with Thanos and object storage—each offering data persistence and load distribution to enhance system stability and performance.
This article demonstrates how to set up Prometheus alerting rules to monitor Kubernetes Pod phases, explains the different Pod states, provides example alert expressions, and discusses practical solutions to avoid false alarms during deployments.
This article explains how to leverage smart-doc to automatically generate JMeter performance testing scripts from API code, import them into JMeter, set up Prometheus monitoring and Grafana dashboards, and highlights the automation benefits for backend development and operations workflows.
This article compares Prometheus and Zabbix, covering their histories, architectural differences, storage models, configuration complexity, community activity, and container support, to help you decide which monitoring solution best fits physical servers or cloud-native environments.
This guide explains how to build comprehensive system and application monitoring using the USE (Utilization‑Saturation‑Errors) method, outlines essential performance metrics, and walks through setting up a full monitoring stack with Prometheus, Grafana, and ELK components, including data collection, storage, alerting, and visualization.
This article explains what Prometheus is, why TDMQ Pulsar needs Prometheus integration, outlines the two monitoring designs, and provides a detailed, step‑by‑step guide with configuration examples to expose Pulsar metrics for Prometheus collection.
This article explains why a global view is needed when Prometheus metrics are scattered across many instances, compares community approaches such as Federation, Thanos, and Remote Write, and details Alibaba Cloud's Global Aggregation Instance and Remote Write solutions with configuration examples and a real‑world case study.
This article explains how to design a comprehensive monitoring system using the concise USE (Utilization, Saturation, Errors) method, outlines essential system and application metrics, and demonstrates practical implementation with Prometheus, Grafana, and related open‑source tools.
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 for common MySQL performance indicators, providing a complete end‑to‑end monitoring solution.
This tutorial explains how to install Redis Exporter, configure Prometheus to scrape Redis metrics, visualize them in Grafana, and set up alert rules for Redis, providing step‑by‑step commands, configuration snippets, and screenshots for a complete monitoring solution.
This article explains why monitoring is vital for microservice architectures, outlines the core metrics such as performance, health, tracing, and resource usage, and reviews popular monitoring frameworks like Prometheus, Grafana, Zipkin, and the ELK Stack.
This guide shows how to enable Horizontal Pod Autoscaling for traffic‑driven workloads by leveraging cAdvisor's container network receive and transmit byte counters, converting them to per‑second rates with Prometheus‑adapter, and validating the custom metric through Kubernetes commands and console views.
This multi‑chapter guide provides in‑depth, hands‑on instruction for configuring and optimizing all Prometheus components, exploring Kubernetes monitoring, source‑code analysis, custom exporter development, high‑availability setups, service discovery, resource‑efficient scraping, and integrating Thanos for long‑term storage.
This article analyzes why a single Prometheus instance repeatedly runs out of memory and crashes, explains the underlying storage mechanisms, and presents practical solutions such as metric reduction, retention tuning, federation architecture, and remote storage integration to improve stability and scalability.
This guide explains the architecture of VictoriaMetrics, details a step‑by‑step Helm deployment on a Kubernetes cluster, covers data collection from multiple clusters, storage persistence, Grafana dashboard setup, and alerting configuration using vmalert and webhook integration.
This comprehensive guide explains Prometheus' architecture, metric collection models, storage format, query language (PromQL), alerting workflow, configuration reload methods, metric types, custom exporters, and how to visualise data with Grafana, providing a complete end‑to‑end monitoring solution.
This article explains how to design and implement Prometheus metrics for application monitoring, covering the selection of monitoring targets, golden metrics, label conventions, naming rules, histogram bucket choices, and Grafana visualization tricks to help engineers build reliable observability pipelines.
This guide walks through installing and configuring Prometheus, Grafana, and Node Exporter on a Linux server using Docker, shows how to set up monitoring dashboards, customize PromQL queries, and verify the monitoring system, providing complete steps and code snippets for a functional host monitoring solution.
This tutorial demonstrates how to monitor Nginx using Prometheus by enabling the stub_status module, installing and running the Nginx Exporter, configuring Prometheus scrape jobs, and optionally visualizing the collected metrics in Grafana, providing a complete end‑to‑end monitoring solution.
This article demonstrates how to create a custom insertable annotation processor in Java to automatically inject the jar version into component constants at compile time, eliminating manual updates and enabling Prometheus monitoring of library usage across versions.
This article provides a comprehensive comparison between Zabbix and Prometheus, covering their functional architecture, metric collection methods, data storage, query capabilities, visualization options, and alerting mechanisms, helping readers decide which monitoring system best fits their enterprise needs.
This guide walks through Istio's observability stack, showing how to configure Prometheus for metrics collection, deploy Jaeger for distributed tracing, and set up Kiali for visualizing the service mesh, while covering annotations, TLS settings, weighted routing, and configuration validation.
This article explains monitoring fundamentals, distinguishes black‑box and white‑box approaches, outlines key metrics and their aggregation, and provides a comprehensive guide to Prometheus architecture, data model, query language, and practical examples for CPU, memory, and disk usage monitoring.
This article explains the design and implementation of a robust payment‑channel monitoring system that uses Redis for time‑series storage, Prometheus for metrics, and custom algorithms to achieve fast fault detection, low false‑alarm rates, and automatic channel switching.
This article explains how to use Prometheus to collect, define, and alert on business‑level metrics in a Kubernetes environment, covering observability concepts, metric types, Go code examples, and scraping configurations for reliable monitoring.
This guide explains monitoring fundamentals, clears common misconceptions, compares black‑box and white‑box approaches, outlines key metrics such as latency, traffic, errors and saturation, and provides a deep dive into Prometheus architecture, data model, query language, and practical examples for CPU, memory, and disk monitoring.
This article walks through deploying Apache APISIX and DeepFlow in a Kubernetes cluster, configuring eBPF‑based AutoTracing and OpenTelemetry integration, enabling Prometheus metrics, accessing logs and continuous profiling, and visualizing unified observability data via Grafana dashboards.
Cloud Music’s middleware team built the Pylon APM monitoring system on VictoriaMetrics, combining exporters, vmagent, Nacos, Flink‑based pre‑aggregation recording rules and vminsert for collection with Grafana, a custom Proxy and vmselect for querying, achieving millisecond‑level latency, metric‑trace correlation, stability improvements, and cost‑effective storage for nearly 700 million active time series.
This tutorial walks you through installing Helm, using Helm commands to find and install the Prometheus Helm chart, exposing the Prometheus service, and accessing the monitoring UI on a Minikube Kubernetes cluster, complete with code snippets and screenshots.
This guide walks through installing and configuring the open‑source Nightingale monitoring platform on a Linux server, including prerequisite MySQL and Redis setup, Prometheus deployment, Nightingale binary installation, service configuration, and adding the Categraf collector for comprehensive system metrics.
To handle growing payment traffic and unreliable third‑party gateways, the team at Zhuanzhuan designed an automated payment‑channel management platform that uses a custom Redis‑based time‑series store, Prometheus monitoring, and a sliding‑window failure‑rate algorithm to detect, alert, and eventually auto‑switch faulty channels.
Alibaba Sentinel 1.8.7 introduces regex‑based resource matching, Prometheus metric export, default circuit‑breaker rules, and an enhanced RateLimitController, while outlining the upcoming 2.0 features such as traffic routing, traffic coloring, and self‑healing capabilities for cloud‑native microservices.
This guide shows how to set up a MySQL server and a mysqld_exporter using Docker Compose, configure Prometheus to scrape the exporter, and create alert rules for MySQL downtime and slow queries, providing a complete monitoring solution.
This article presents a detailed case study of how ZhaiZhai designed and implemented a unified monitoring platform—combining business services, middleware, and operations resources—by selecting Prometheus and M3DB, automating Grafana dashboards, creating a low‑noise alerting system, and achieving large‑scale observability with significant cost and efficiency gains.
This article compares two popular open‑source Kubernetes monitoring and alerting solutions—kube‑prometheus and Nightingale—detailing their features, deployment steps, advantages, drawbacks, and providing guidance on choosing or combining them based on specific operational needs.
Facing exploding metric volumes, high resource consumption, and fragile operations, Xiaohongshu's observability team completely rebuilt its metrics pipeline using Victoriametrics, achieving ten‑fold performance gains, minute‑level scaling, high‑availability, cost reduction, and robust multi‑cloud active‑active deployment while preserving data safety and query speed.
This guide explains how to install, configure, and run Prometheus Alertmanager with Docker, set up routing and receivers, integrate it with Prometheus alert rules, test alerts, customize email templates, and optimize notification settings for reliable monitoring and alerting.
This guide translates and condenses six frequent errors new Prometheus users make—high‑cardinality labels, losing valuable tags during aggregation, using bare selectors, omitting the for field, choosing too‑short rate windows, and applying rate‑related functions to wrong metric types—offering practical fixes to improve monitoring reliability.
This guide walks through a full Kubernetes monitoring solution using cAdvisor, node_exporter, Prometheus, and Grafana, covering architecture, data collection, service discovery, deployment steps with DaemonSets, and detailed YAML configurations for a production‑ready observability stack.
Grafana Labs engineer Bryan Boreham explained at KubeCon how a series of code changes, label optimizations, and Go runtime tuning reduced Prometheus memory consumption by roughly 50%, detailing the technical challenges, solutions, and measurable impact on modern monitoring deployments.
The missing trace data in two Go services was caused by the GoFrame tracing middleware recording the gzip‑compressed /metrics response body as a UTF‑8 string, which the OpenTelemetry exporter rejected as invalid UTF‑8; disabling Prometheus compression or decompressing the body before logging resolves the issue.
This article explains how to install and run the lightweight, certified Kubernetes distribution K3s on a workstation, using k3d as a wrapper, and demonstrates deploying operators, Prometheus, and Grafana with full command‑line examples and configuration files.
This article reviews why HTTPS certificate expiration checks are often missed and introduces several open‑source monitoring tools—including blackbox_exporter, EaseProbe, uptime‑kuma, domain‑admin, and a simple shell script—to help operations teams ensure timely certificate renewal.
This article details the recent technical upgrades to Alibaba Cloud's SLS Prometheus storage engine, describing how compatibility with PromQL was retained while achieving more than tenfold query speed improvements, reducing costs through smarter aggregation writes, built‑in downsampling, global caching, parallel computation, and push‑down processing, and presenting benchmark comparisons with open‑source solutions.
This article details the design and implementation of the Pylon APM monitoring platform for NetEase Cloud Music, covering background challenges, the choice of Pinpoint, extensions to trace models, tail‑based exception sampling, Prometheus integration, automated JStack collection, and the resulting APM product features.
This article compares the open‑source monitoring solutions Prometheus and Zabbix, outlining their histories, architectures, data collection methods, scalability, storage models, configuration complexity, community activity, and suitability for different environments such as traditional servers versus cloud‑native container platforms.
This article explains how to design and deploy a complete monitoring solution using Prometheus, various exporters, Grafana, and Alertmanager on Docker and Kubernetes, covering installation, configuration, visualization, and best‑practice tips for reliable operations monitoring.
This guide walks you through preparing a Kubernetes cluster, creating deployment manifests, configuring Grafana and Prometheus, and verifying the monitoring setup, including code snippets and step‑by‑step commands for a seamless installation on a lightweight cloud server.
This article explores why logs are essential in software development, outlines when to record them, discusses the value of logging in large-scale distributed systems, and examines the capabilities required of log‑operation tools such as APM, metrics, tracing, ELK, Prometheus, and custom batch querying solutions.
This article explains how to use Prometheus to monitor business‑level metrics in a Kubernetes environment, covering observability fundamentals, metric definitions, metric types, exposing metrics via a /metrics endpoint, and practical Go code examples for defining, recording, and scraping custom metrics.
This guide explains why Prometheus is ideal for Kubernetes monitoring, walks through installing Prometheus, configuring targets and alerts, deploying Alertmanager and Grafana via Helm, and demonstrates testing alerts with load generation, providing complete code snippets and visual results.
This article visually dissects Prometheus, explaining its architecture, core features, data collection methods, exporter role, PromQL query language, and alerting workflow, while contrasting it with ELK and highlighting practical configuration examples for real‑world monitoring.
This guide walks through installing OpenTelemetry Collector on a Kubernetes cluster using Helm, configuring DaemonSet and Deployment collectors, integrating Prometheus for metrics, and customizing receivers, processors, and exporters to achieve comprehensive observability of nodes, pods, containers, and cluster resources.
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.