This article explains why the ELK stack is useful for large‑scale log collection and analysis, then provides detailed installation, configuration, and integration steps for Elasticsearch, Logstash, and Kibana on both macOS and Linux, including common pitfalls and memory‑tuning tips.
This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures IP, URL, HTTP method, parameters, results, execution time, and error details, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.
This tutorial walks you through why ELK is essential for large‑scale log collection, shows a simple architecture diagram, and provides detailed installation and configuration steps for Elasticsearch, Logstash, and Kibana on both macOS and Linux, including common pitfalls and Java integration.
This article explains how Log4j2's RollingFileAppender works, covering the roles of TriggeringPolicy and RolloverStrategy, showing various filePattern configurations, detailing the DefaultRolloverStrategy max parameter, introducing DeleteAction for custom file cleanup, and providing Java demo code and test configurations.
This guide explains how to configure comprehensive JVM garbage-collection logging—including basic GC details, object age distribution, heap snapshots, pause times, safepoint statistics, and reference processing—while using timestamped filenames and JVM log rotation to avoid overwriting and manage file size effectively.
Logback, the open‑source logging framework created by the log4j founder, offers faster performance, extensive testing, native SLF4J support, flexible configuration, automatic reload, advanced appenders and rolling policies, making it a superior replacement for log4j in modern Java backend applications.
This article walks through a cloud-native approach to collect Kubernetes container logs using Fluentd and forward them to Loki, covering why Fluentd is chosen, required plugins, Docker log handling, multi-worker configuration, metadata filtering, label customization, and Loki output settings.
This article introduces the BizLog SDK for Spring Boot, explains how to add the Maven dependency, enable the @EnableLogRecord switch, use @LogRecordAnnotation for various logging scenarios, customize operators, details, categories, and parse functions, and shows how to extend the framework with custom services and implementations.
Gaode Ride‑Hailing created a comprehensive 360° observability platform—standardized logging, distributed tracing, multi‑domain metrics, visual dashboards, and an incident workflow—that transforms raw data into actionable insights, accelerates root‑cause analysis, and enables automated fault defense for its large‑scale cloud‑native microservice system.
This guide walks through installing Elasticsearch, Kibana, and Filebeat, configuring Filebeat to ship Spring Boot logs to Elasticsearch, and verifying the logs via Kibana, including a sample Spring Boot controller that generates both normal and error log entries.
This tutorial walks through setting up Spring Boot 2.3.8 with Spring Cloud Hoxton, adding OpenFeign dependencies, configuring service URLs, customizing Feign client defaults, enabling logging, setting request timeouts, and integrating Hystrix circuit breaker with fallbacks and factories.
This article analyzes the root causes of a company's unstable Kubernetes clusters and presents a comprehensive solution covering a revamped CI/CD pipeline, federated monitoring and alerting, centralized logging, documentation practices, and clear traffic routing to achieve high reliability and stability.
This article describes the requirements, architecture, API design, database selection, retention policies, security measures, and performance optimizations of a new iOS log system that records business, network, and player logs, uses WCDB for storage, and employs active pull and encrypted chunked uploads to improve issue diagnosis.
This guide walks through the complete architecture and step‑by‑step deployment of a billion‑scale ELK logging system, covering Filebeat agents, Kafka buffering, Logstash processing, Elasticsearch indexing, and Kibana visualization, including configuration files, version details, and best‑practice tips for scaling and security.
This guide walks through installing Loki and Promtail in local mode, configuring Nginx to emit JSON logs, adjusting Promtail settings, and using LogQL’s JSON extraction (with and without parameters) to build queries that count successful Nginx requests over a selectable time range.
This article explains Docker and Kubernetes logging challenges, compares logging drivers, introduces S6‑based container logging, and presents a node‑level log‑agent architecture using Filebeat, Logrotate, Kafka, and Elasticsearch to achieve reliable, auto‑rotating log collection in production environments.
This tutorial walks you through setting up ElasticSearch, Kibana, and Logstash, configuring them for a Spring Boot application, and using Kibana to explore indexed logs, providing code snippets, configuration files, and visual instructions for a complete ELK integration.
This article explains how malicious newline characters in logged usernames can cause log injection, demonstrates a simple input‑sanitizing method, shows how to use Log4j2's %enc{%m}{CRLF} pattern and a custom ThrowablePatternConverter to ensure all log messages and exception stacks remain on a single safe line.
This article explains the limitations of Docker‑based logging, compares logging drivers, and presents a Kubernetes‑wide log collection architecture that uses an S6‑based base image, Filebeat, logrotate, Kafka, and Elasticsearch to achieve reliable, scalable log aggregation.
This comprehensive tutorial walks you through choosing Koa, setting up a project, refactoring routing, handling parameters, configuring middleware for error handling, CORS, logging, validation, and organizing config, controller, service, and model layers for a robust Node.js backend.
This article explains Docker and Kubernetes logging challenges, compares engine and container logs, shows why the Docker daemon becomes a bottleneck, and demonstrates a scalable solution using S6‑based images, Filebeat, logrotate, and a node‑agent architecture to collect, rotate, and forward logs to Kafka and Elasticsearch.
This article explains how to collect, process, and visualize Flink job logs on Kubernetes using an EFK stack with Fluentd, covering logging architectures, deployment of Elasticsearch, Kibana, and Fluentd, and the backend logic for querying and displaying logs in a feature platform.
This article explains best practices for using the SLF4J façade with Logback, covering when to log, proper log levels, parameterized message formatting, avoiding string concatenation, and guidelines for error, warning, info, debug, and trace logging in Java backend systems.
This article explains the evolution and inter‑relationships of Java logging libraries such as JCL, SLF4J, Log4j, Logback and JUL, shows how to choose and configure adapters to achieve unified logging across frameworks, and provides troubleshooting tips and coding guidelines.
The article analyzes the instability of a company's Kubernetes clusters, identifies root causes such as unstable release processes, lack of monitoring, logging, and documentation, and proposes comprehensive solutions including a Kubernetes‑centric CI/CD pipeline, federated Prometheus monitoring, Elasticsearch logging, centralized documentation, and integrated traffic management with Kong and Istio.
This article explains how to design and implement a unified log collection architecture for Docker containers and Kubernetes clusters using S6‑based images, Filebeat, logrotate, Kafka, Logstash, and Elasticsearch, addressing common challenges such as log rotation, daemon bottlenecks, and dynamic configuration.
This article details the step‑by‑step creation of a Python‑based API automation testing framework, covering project structure, configuration files, a reusable logging module, HTTP request handling with requests, common utilities for Excel and XML, MySQL database access, email reporting, and the test runner setup.
This article presents a comprehensive case study of Ctrip's unified accounting platform, detailing its evolution from legacy systems, architectural redesign, component decomposition, logging, sharding, asynchronous processing, database strategies, exception handling, and daily settlement mechanisms to achieve agility, decoupling, and reusability.
Amid microservice and distributed architectures, this article explains how to design a comprehensive log analysis system—covering collection, storage, consumption, key data points, collection methods, and practical use cases like automated test generation, issue localization, and real‑time exception monitoring—to ensure system stability.
A developer recounts a five‑day debugging saga where a new lock‑free network queue caused intermittent core dumps, ultimately traced to differing GCC optimization behaviors, and shares practical lessons on bug attitude, reproduction, static analysis, and effective logging.
This article explains the evolution, relationships, and dependencies of Java logging libraries such as Log4j, JUL, JCL, SLF4J, and Logback, and provides practical guidance on configuring adapters, solving common conflicts, and unifying logging output across frameworks like Spring.
This article explains why the Grafana Loki log system was chosen over ELK for container cloud environments, detailing its lightweight design, cost‑effective architecture, components like Distributor, Ingester, and Querier, and how it integrates with Prometheus labels to simplify log collection and querying in Kubernetes.
Effective error logging provides crucial clues for troubleshooting, yet many logs lack context, consistency, or detail, making debugging time‑consuming; this article explains common error sources, fourteen typical causes, improvement measures, and practical guidelines—including formatting rules and code examples—to help developers write clear, actionable logs.
This article shares Ctrip International Ticketing’s cloud‑native migration experience, covering infrastructure‑as‑code with Terraform, managed Kubernetes, centralized logging and monitoring using Elastic Search, Prometheus, Grafana and Thanos, and practical cost‑optimization techniques such as auto‑scaling, spot instances, storage tiering and network proxying.
This article explains how Baidu’s search middle‑platform implements full‑stack observability—metrics, tracing, logs, and topology analysis—to reliably monitor and troubleshoot a system handling billions of requests across hundreds of thousands of microservice instances.
This article describes how to programmatically configure Log4j2's LoggerContext to separate middleware logs into dedicated files, encapsulate the setup in a shared jar, expose a logger retrieval API, and integrate it into middleware components, reducing business log interference and storage costs.
TLog provides a non‑intrusive, storage‑free solution for microservice log tracing by automatically tagging logs with a TraceId that propagates across services, supporting major logging and RPC frameworks and enabling rapid integration with Spring Boot in about ten minutes.
SOFABoot, an Ant Financial open‑source framework built on Spring Boot, enhances microservice development by adding readiness checks, class and log space isolation, unified middleware integration, and modular development capabilities, addressing class conflicts and monitoring challenges in large‑scale deployments.
To improve SaaS B2B product efficiency and revenue retention, the article examines the unique challenges of frontend development in enterprise services, proposes a client‑side logging library—woodpecker‑log—detailing its design, storage with IndexedDB, performance considerations, API, and integration for rapid customer issue diagnosis.
This article explains why exception handling in Java is challenging and presents ten practical best‑practice guidelines—including using finally or try‑with‑resources, declaring specific exceptions, documenting throws, providing clear messages, catching specific exceptions first, avoiding Throwable, logging properly, and preserving original causes—to write more robust and maintainable code.
The article chronicles how the fast‑growing startup Meddy transformed its monolithic AWS setup by adopting managed services such as RDS, S3, Elastic Beanstalk, Elasticsearch, Application Load Balancer, serverless Lambdas, ElastiCache, and Grafana Loki to achieve scalable, reliable, and observable cloud infrastructure.
This article explains the evolution and inter‑relationships of Java logging libraries such as Log4j, JUL, JCL, SLF4J and Logback, shows how to configure adapters to unify logging across frameworks, addresses common runtime issues, and provides coding‑style recommendations for consistent log output.
This article explains how Tengine logs request timing, why the server‑side request_time_msec can appear short while clients experience longer delays, and provides practical methods to analyze access_log entries, understand upload/download latency differences, minimum download speeds, and special status codes such as 400, 408, and 499.
This article presents nine essential Java exception handling best practices, including using finally blocks or try‑with‑resources for resource cleanup, specifying precise exception types, documenting throws clauses, providing descriptive messages, catching specific exceptions first, avoiding catching Throwable, not ignoring exceptions, and correctly wrapping exceptions without losing the original cause.
This article outlines the golden rules for constructing Spring Boot microservices, covering monitoring with Spring Boot Admin and Grafana, exposing metrics via Actuator, centralized logging with ELK, clear API documentation using Swagger, YApi or smart‑doc, transparent build info, and keeping dependencies up‑to‑date.
This guide outlines essential Spring Boot best practices for microservices, covering monitoring with Admin and Grafana, Actuator metrics, centralized logging via ELK, clear API docs using Swagger, YApi or smart-doc, build-info transparency, and keeping dependencies up-to-date.
This article explains the layered architecture of microservice monitoring, detailing five monitoring levels—from infrastructure to end-user experience—along with essential monitoring points such as logs, metrics, tracing, alerts, and health checks, and presents a typical monitoring stack using agents, Kafka, ELK, and InfluxDB.
This article explains why detailed Linux system operation auditing is essential for security and troubleshooting, outlines practical filtering rules to avoid redundant or sensitive logs, and compares five auditing approaches—history, custom bash, snoopy, auditd, and eBPF—detailing their strengths, limitations, and configuration examples.
Auditing Linux system operations is essential for security and troubleshooting, but excessive logs can overwhelm analysis; this guide outlines common filtering rules and compares five recording methods—history, custom bash, snoopy, auditd, and eBPF—highlighting their advantages, limitations, and practical configuration examples.
This guide introduces Loki, a Prometheus‑inspired, label‑based log aggregation system for Kubernetes, outlines its key features and components, and provides step‑by‑step Helm installation, Nginx‑Ingress and Promtail configuration, plus Grafana integration for visualising logs.
This article presents a ready‑to‑use ELK‑based solution for private‑deployment environments, detailing design principles, rapid one‑click deployment via Jenkins, log and metric collection with Filebeat and Metricbeat, alerting using ElastAlert, and visualization in Kibana, while emphasizing simplicity, robustness, and minimal operational overhead.
This article explains the evolution and relationships of Java logging libraries, shows how to resolve common issues like missing logs or jar conflicts, and provides practical guidance for configuring unified logging across frameworks such as SLF4J, Logback, Log4j, and Spring.
Learn how to enhance Python debugging using the PySnooper library, covering quick installation, simple examples, advanced features like output redirection, variable watching, depth control, thread info, custom representations, and remote debugging tips, all illustrated with clear code snippets and screenshots.
This article explains the evolution and inter‑dependencies of Java logging frameworks such as JCL, Log4j, JUL, SLF4J and Logback, shows how to configure them to avoid jar conflicts and missing logs, and provides practical steps and troubleshooting tips for unified logging in Java projects.
This tutorial explains the fundamentals of Python logging, covering when to log, the standard log levels, simple console and file examples, multi‑module logging, variable interpolation, message formatting, date/time handling, and advanced concepts such as loggers, handlers, formatters, configuration methods, and best practices for library developers.
The article explains typical Logback misconfigurations—such as logger inheritance errors and improperly set LevelFilter—that cause duplicate log entries, and provides step‑by‑step corrections like disabling additivity and configuring filter attributes to eliminate redundant logging.
This article explains the adapter pattern, illustrates its role in SLF4J by analyzing the Logger interface, Log4jLoggerAdapter, and related factory code, compares object and class adapters, and discusses the pattern's advantages and drawbacks in Java logging frameworks.
The article presents a comprehensive case study of Haodf.com's transition to a micro‑service architecture, detailing the challenges of service stability and observability, the design of a unified governance platform with log‑holographic analysis, real‑time alerts, application profiling, SLO/SLA definition, and future roadmap for capacity and reliability improvements.
This guide explains how to prepare resources, create a local‑volume storage class, install the Elasticsearch and Cluster Logging operators, and configure a persistent EFK stack on OpenShift, including YAML definitions, command‑line steps, and best‑practice notes on node selectors and tolerations.
This article explains MyBatis's logging architecture, covering the supported log implementations, the role of SLF4J, how MyBatis selects and configures a logger via LogFactory, and the use of JDK dynamic proxies to route JDBC logging through separate logger objects.
This article explains how to create and use custom Java annotations together with Spring AOP to implement unified logging, method‑level parameter validation, and other cross‑cutting concerns, providing practical code examples and best‑practice recommendations for backend developers.
This article explains how MyBatis loads and categorizes logging implementations, details the role of SLF4J and other frameworks, describes the LogFactory adapter selection process, and shows how JDBC log proxies use dynamic proxies to output SQL execution details.
This article walks through a real‑world Java code refactor that adds login IP and allowed‑time security checks to an e‑commerce platform, highlighting problems in the original implementation and detailing step‑by‑step improvements such as utility extraction, loop simplification, constant usage, and enhanced logging.
This article explains the essential role of logging and recovery mechanisms—especially the ARIES algorithm—in ensuring ACID properties, covering physical vs logical logging, optimization techniques like group commit and early lock release, and the three-phase recovery process.
This article provides a comprehensive guide to configuring Logback in Spring Boot, covering Maven dependencies, SLF4J usage, step‑by‑step XML setup, application.yml integration, controller logging code, Lombok shortcuts, appender types, logger definitions, log levels, rolling policies, filters, and best practices for backend development.
This article investigates why using Log4j2's ConsoleAppender can block business threads, analyzes thread stack traces and performance bottlenecks, and demonstrates how switching to AsyncLogger with Disruptor dramatically improves logging throughput and eliminates service deadlocks.
This article demonstrates how to use Spring Boot AOP to automatically record operation and exception logs by defining log tables, adding the AOP starter dependency, creating a custom @OperLog annotation, implementing an aspect that captures request details and errors, and applying the annotation to controller methods, providing a clean, reusable logging solution for Java backend applications.
This guide walks through building a secure, production‑grade logging pipeline by deploying an ELK stack (Elasticsearch, Logstash, Kibana) with X‑Pack security, a Kafka message queue with SASL authentication, and Filebeat agents, covering environment preparation, certificate generation, configuration files, and startup scripts.
This article surveys the major Java logging frameworks—including Log4j, Log4j2, Logback, SLF4J, J.U.L, and Jakarta Commons Logging—explains their histories, architectural differences, typical use‑cases, and provides practical guidance for selecting the most suitable option for new projects.
This article explains how to choose and integrate Java logging frameworks, use SLF4J with Logback, understand Spring Boot's default logging setup, customize log output, and switch between implementations such as Log4j2, providing practical code snippets and configuration examples.
This article demonstrates how to configure Python's logging module for console and file output, extend it with HTTPHandler for remote logging, and improve performance by using custom handlers, threading, thread pools, and asynchronous aiohttp calls to avoid blocking the main program.
This article explains how to seamlessly replace Spring Boot's default Logback logging framework with alternatives like Log4j2 by leveraging the SLF4J facade, covering version requirements, dependency management, configuration files, and detailed XML examples for various log levels.
This tutorial walks through creating a Python program that scrapes product links, names, and images from a Taobao store, logs the process, exports the data to Excel, and provides a user‑friendly Tkinter GUI for searching and controlling the scraper.
This article explains how to configure logging in Spring Boot, covering supported versions, log levels, available logging frameworks, default Logback setup, code usage with Lombok, customizing log levels, directing output to files, formatting patterns, and detailed Logback XML configuration.
This article examines the fundamental differences between traditional disk‑based DBMS and modern in‑memory databases, covering buffer management, lock versus latch mechanisms, logging and recovery, performance overhead, historical evolution, and architectural innovations that enable high‑performance memory‑resident data processing.
Version 1.19 of Kubernetes, released after a 20‑week cycle, introduces a year‑long support window, storage capacity tracking, generic ephemeral volumes, CSI health monitoring, GA Ingress, structured logging with klog, kubelet TLS certificate rotation, plus numerous features graduating to stable and major enhancements across scheduling, security, and API design.
Kubernetes 1.19, released after a 20‑week cycle, introduces a one‑year support window, storage capacity tracking, generic ephemeral volumes, CSI health monitoring, Ingress reaching GA, structured logging, new klog methods, and kubelet TLS certificate rotation, while providing extensive release notes and ecosystem updates.
Kubernetes 1.19, released after a 20‑week cycle, introduces a year‑long support window, storage capacity tracking, generic ephemeral volumes, CSI health monitoring, Ingress GA, structured logging, new klog methods, kubelet TLS certificate rotation, and dozens of other stable and major feature updates.
This tutorial explains how to download Docker images for Elasticsearch, Kibana, and Logstash, create a Docker‑Compose configuration file, launch the ELK stack containers, verify their operation, customize Logstash to monitor log files, and finally use Kibana to search and analyze the collected logs.
This tutorial walks through installing and configuring Filebeat, Kafka, Logstash, Elasticsearch, and Kibana, detailing version requirements, file permissions, YAML settings, startup commands, topic verification, and how to ingest and visualize log data in Kibana.
This article presents a comprehensive design for a WeChat Mini Program frontend error monitoring system, covering background challenges, architectural and process design, SDK implementation, reporting mechanisms, and a visualized backend to help developers quickly locate and resolve runtime exceptions.
This article explains the motivations behind choosing Loki over traditional ELK/EFK stacks for container cloud logging, outlines ELK's drawbacks, describes Loki's cost‑effective architecture and components such as Distributor, Ingester, and Querier, and highlights its scalability in cloud‑native environments.
This guide explains Docker's two log types, how to locate engine logs on various Linux distributions, how to use the docker logs command, and provides detailed configuration examples for each Docker log driver—including local, json‑file, syslog, and journald—plus strategies for handling file‑based container logs in production environments.
This article presents a practical case study of front‑end error monitoring for a real‑estate broker web site, detailing the background problem, pain points, analysis, design adjustments, code implementations, data collection, reporting strategies, and the resulting improvements in issue‑resolution efficiency.
This article explains how Loki, a lightweight Grafana‑based log system, addresses the heavy resource usage and complexity of ELK/EFK in Kubernetes environments by simplifying architecture, reducing cost, and improving log‑metric integration for faster incident response.
This article explains the motivations behind Loki, its architecture and components, how it reduces the cost and complexity of log and metric querying compared to ELK, and details its write‑read pipeline, scalability, and integration with Kubernetes and Prometheus.
This article explores the principles and practical guidelines for designing error codes, comparing log‑oriented and external‑facing standards, analyzing numeric versus alphanumeric formats, and presenting recommended structures to improve traceability, memorability, and cross‑team communication in modern backend systems.
This article demonstrates how to use MyBatis to update records with sub‑queries, batch‑insert list‑type attributes, defines the related Java bean, and implements a Spring servlet filter (with request and response wrappers) to log request parameters and response results.
iQiyi’s full‑link automated monitoring platform unifies tracing, metric and log collection with deep offline and real‑time analysis, delivering a DAG‑based call graph, near‑real‑time ingestion of tens of millions of logs, multi‑dimensional alerts and rapid root‑cause diagnosis that cut error‑lookup time by over 50 % and now serves as a core component of the company’s microservice reference architecture.
This article examines common operation‑log types and compares two implementation approaches—traditional AOP with annotations and a database binlog‑based solution—detailing their advantages, drawbacks, code examples, database design, future enhancements, and practical deployment considerations.
This guide explains how to enable gzip compression, set cache headers, activate HTTP/2, fine‑tune logging, and apply rate‑limiting in NGINX to dramatically reduce bandwidth consumption while improving site performance and server efficiency.
This guide explains how to use the Arthas logger command to change Java logger levels on‑the‑fly without restarting the JVM, demonstrates a complete Log4j2 XML configuration, and provides a runnable Java example that continuously emits logs at various levels.
This article provides a concise Laravel Log quick reference, detailing the seven RFC‑5424 log levels, usage examples, how to retrieve the Monolog instance, add listeners, and enable and fetch SQL query logs, followed by motivational reflections on perseverance and growth.
This article outlines six frequent code review pitfalls—including missing change notes, overusing generic exception handling, blind trust in third‑party inputs, overly broad variable scopes, lack of staged results, and excessive logging—and offers practical recommendations to improve code quality and maintainability.
Sentinel 1.7.2 introduces a Logger SPI extension, Zuul 2.x gateway flow‑control, SOFARPC adaptation, and numerous other enhancements, expanding its microservice, API gateway, and service‑mesh support across Java, C++, and Go ecosystems.
This article shares practical experiences from a large internet company's containerization project, covering monitoring strategies, logging pipelines, Helm-based continuous delivery, Mutating Admission Webhook sidecar injection, custom PodIP via Calico, GoCron task scheduling, event collection, and resource‑time simulation techniques.
This step‑by‑step guide shows how to provision a single‑node Elastic Stack with TLS‑enabled authentication, configure Kibana and Filebeat modules, and verify distributed log collection in a Vagrant‑based CentOS 8 environment.
This article provides comprehensive API design guidelines covering routing naming conventions, request methods, parameter structures, security measures, response formats, signature design, logging platform setup, and idempotency strategies to help backend developers create consistent and reliable interfaces.
This article explains how to replace Flink's default Log4j logger with Logback by adding Maven dependencies, excluding transitive Log4j artifacts, updating Flink's lib directory, and customizing Logback XML configurations including a rolling file appender and optional email alerts.
This article explains why log collection in Kubernetes is more complex than on traditional VMs, compares passive and active collection methods, evaluates stdout versus file output, and provides practical recommendations and deployment guides for small, medium, and large clusters.
