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.
This article explains how Grafana Mimir extends Prometheus and Alertmanager to provide a horizontally scalable, highly available, multi‑tenant monitoring solution for Kubernetes, covering its architecture, key components, compression mechanisms, deployment steps, and configuration of Alertmanager and multi‑tenant support.
This article explains how to achieve comprehensive service governance in a microservice architecture using SpringCloud Alibaba's Nacos and Dubbo, covering service registration and discovery, load balancing, rate limiting and circuit breaking with Sentinel, configuration management, and monitoring with Prometheus and SkyWalking.
This article explains how to prepare Linkerd for production use by covering high‑availability deployment, Helm chart installation, Prometheus metric handling, external Prometheus integration, multi‑cluster communication, and additional operational best‑practices such as resource tuning and security considerations.
This article explains how to build comprehensive system and application monitoring using the USE (Utilization, Saturation, Errors) method, outlines key performance metrics, and details the architecture of tools like Prometheus, Grafana, ELK, and distributed tracing to quickly detect and resolve bottlenecks.
Effective monitoring combines comprehensive system and application metrics—using the USE (Utilization, Saturation, Errors) method to pinpoint resource bottlenecks, and leveraging tools like Prometheus, Grafana, and ELK stacks for data collection, storage, querying, alerting, visualization, and full‑stack tracing across distributed services.
This article shares practical experiences and solutions for improving an Alertmanager‑based alert system, addressing problems such as noisy alerts, lack of escalation, missing recovery notifications, suppression limitations, and cumbersome silence management by redesigning architecture, adding custom scripts, and extending database support.
This guide walks through deploying a MySQL primary‑replica cluster on Kubernetes using Helm charts, configuring persistent volumes, exposing services, and adding Prometheus and Grafana monitoring, while also covering installation, testing, and clean‑up steps.
This tutorial explains how to deploy a primary‑replica MySQL cluster on Kubernetes using Helm, configuring persistent volumes, setting up Prometheus monitoring, and provides commands for installation, verification, and clean removal, all with detailed code snippets.
This article introduces essential Redis operational tools, covering real‑time monitoring with the INFO command and Prometheus‑exporter, data migration using Redis‑shake, consistency checking via Redis‑full‑check, and cluster management through CacheCloud, providing practical guidance for administrators.
This guide walks through designing a simple front‑end/back‑end microservices architecture, implementing it with Spring Boot and Eureka, deploying the services on a Kubernetes cluster using K8seasy, and adding high‑availability features such as multi‑instance registration, Prometheus‑Grafana monitoring, Zipkin tracing, and Sentinel flow‑control.
This guide walks through installing KubeSphere on Tencent Cloud's TKE, covering official documentation steps, common issues such as CBS disk size limits, uninstall complications, monitoring gaps on super‑nodes, and provides concrete YAML snippets and kubectl commands to resolve them.
This article presents a step‑by‑step solution for consolidating TiDB multi‑cluster monitoring by deploying Consul for service registration, configuring Prometheus to discover services via Consul, and optionally replacing Prometheus with VictoriaMetrics to achieve unified dashboards, scalable data collection, and easier health inspection across dozens or hundreds of instances.
The article describes the motivation, requirements, and architectural design of a highly available, scalable, low‑cost distributed time‑series database built on Mimir, detailing write and read paths, multi‑tenant isolation, compaction, and the performance and cost improvements achieved after deployment.
This article details the design, data‑collection pipeline, monitoring stack, visualization practices, and alert‑response workflow of a globally deployed Alibaba Cloud‑native system that uses ACK, Prometheus, Grafana, and ARMS to achieve end‑to‑end observability across metrics, tracing, and logs.
This article provides a step‑by‑step guide on extending the Kubernetes scheduler, covering configuration of scheduler profiles, implementing out‑of‑tree plugins, integrating Prometheus‑based network traffic scoring, and deploying the custom scheduler both inside and outside a cluster, complete with code samples and troubleshooting tips.
This article walks through setting up real‑time performance monitoring by sending JMeter metrics to InfluxDB via Backend Listener, visualizing them in Grafana, and extending the approach to system metrics with node_exporter, Prometheus, and Grafana, covering configuration steps, code snippets, and query examples.
This article explains the limitations of a standard Prometheus monitoring stack on Kubernetes and demonstrates how to migrate to a Thanos‑based solution for long‑term metric retention, reduced infrastructure cost, and scalable multi‑cluster observability using Terraform and cloud‑native components.
This article explains how to build a comprehensive monitoring system using the concise USE (Utilization, Saturation, Errors) method, outlines key system and application metrics, and demonstrates practical implementation with Prometheus, Grafana, full‑link tracing, and ELK for observability and performance troubleshooting.
Grafana 9.0 focuses on improving user experience for observability and data visualization, introducing visual Prometheus and Loki query builders, an Explore‑to‑dashboard workflow, a revamped heatmap panel, command palette, panel search, trace panels, navigation upgrades, and enhanced alerting, all aimed at making data discovery and investigation more intuitive and efficient.
Learn how to set up Prometheus to scrape Nexus repository metrics, configure authentication, and create insightful Grafana dashboards that visualize component, Jetty, and JVM metrics, enabling proactive troubleshooting and resource optimization for Nexus services.
This article introduces four CNCF‑graduated open‑source projects—Prometheus, Jaeger, OpenTelemetry, and Thanos—that together provide metrics, alerts, tracing, and long‑term storage to improve observability, reduce downtime, and streamline troubleshooting for workloads running on Kubernetes.
This article introduces five popular open‑source network monitoring solutions—Cacti, Nagios Core, Icinga 2, Zabbix, and Prometheus—explaining their main features, supported platforms, data collection methods, and where to obtain them, helping administrators choose the right tool for reliable system oversight.
This tutorial explains how to install Aeraki Mesh sample applications, forward ports to Prometheus and Grafana, and use these tools to query and visualize L7 protocol metrics for Dubbo and Thrift services within an Istio service mesh.
This article explains the key Prometheus metrics for Kubernetes container CPU usage, provides exact PromQL formulas for calculating per‑container CPU percentages, and details how Docker stats reports memory and CPU usage, including the necessary calculations and sample code.
This article compares Prometheus and Zabbix, outlining their histories, architectures, storage models, configuration complexity, community activity, and suitability for different environments, and concludes with recommendations on when to choose each monitoring system.
This article details a practical approach to constructing a semi‑automated monitoring solution for small‑scale services using Prometheus, covering active monitoring concepts, metric types, service‑framework integration, Grafana dashboards, Alertmanager routing, and deployment on Mesos.
Grafana 9.0 introduces a suite of usability enhancements—including a visual Prometheus query builder, a visual Loki LogQL generator, improved Explore‑to‑dashboard workflow, revamped heatmap panel, command palette, panel search, trace panel, navigation upgrades, and alerting refinements—aimed at simplifying observability, data visualization, and operational efficiency.
This comprehensive guide walks you through Prometheus fundamentals, including metric exposure, scraping, storage, querying with PromQL, custom exporter creation in Go, dynamic configuration reloading, and visualizing data with Grafana, while also covering alerting with Alertmanager and best practices for accurate histogram bucket design.
This article explains why downsampling is essential for handling massive time‑series data in Prometheus, describes the aggregation rules and intervals, compares ARMS Prometheus' implementation with other solutions, and shows performance and accuracy results that demonstrate significant query speed improvements.
This comprehensive guide walks you through designing a simple front‑end/back‑end microservice architecture, implementing it with Spring Boot, adding service discovery, monitoring, logging, tracing, and flow control, and finally deploying the entire system on a Kubernetes cluster with high availability and verification steps.
This article provides a detailed overview of Prometheus, covering its architecture, metric exposure, scraping models, storage format, metric types, custom exporter implementation in Go, PromQL query language, built‑in functions, Grafana integration, and alerting with Alertmanager, offering practical code examples throughout.
This article provides a detailed overview of Prometheus, covering its architecture, metric exposure and scraping models, data model, metric types, configuration reload, PromQL query language, custom exporters, Grafana integration, and Alertmanager alerting, with practical code examples and best‑practice tips.
Grafana 9.0 introduces a suite of usability enhancements—including visual Prometheus and Loki query builders, an Explore‑to‑dashboard workflow, a high‑performance heatmap panel, command‑palette navigation, and improved alerting—making data exploration, visualization, and monitoring more intuitive for developers and operators.
This article compares the open‑source monitoring systems Zabbix and Prometheus, detailing their architectures, component roles, strengths, and weaknesses, then describes how to integrate Zabbix data into Prometheus using a custom super_exporter and visualise the combined metrics with Grafana.
This article describes Vivo's practical experience building a cloud‑native monitoring system for large‑scale container clusters, covering the shortcomings of traditional monitoring, the Prometheus‑centric ecosystem, high‑availability architecture, challenges faced, and future directions such as automation and AI‑driven operations.