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 introduces the BizLog SDK for Java, explains its Spring Boot autoconfiguration, demonstrates how to add Maven dependencies, enable logging with @EnableLogRecord, craft log messages using @LogRecordAnnotation with SpEL expressions, and extend the framework with custom parse functions and operator services.
This article explains what logs are, when and why to record them, their value in large‑scale systems, the challenges of log management in micro‑service architectures, and how to design observability platforms using metrics, logging, tracing, and tools such as ELK, Prometheus, OpenTracing, and SkyWalking.
This article provides a detailed tutorial on OpenFeign, covering its purpose, differences from Feign, environment setup, service provider and consumer creation, various parameter passing methods, timeout handling, logging configuration, HTTP client replacement, GZIP compression, and Sentinel-based circuit breaking, while also including practical code examples and configuration snippets.
This article explains how to securely mask sensitive data in log output by using either a conversionRule tag with MessageConverter or a custom utility class, and provides a step‑by‑step guide to integrate a reusable Logback desensitization component with Maven dependency, appender replacement, and YAML configuration.
This article explores why logs are essential in software development, when to record them, their value for debugging, performance, security and business decisions, and how distributed architectures require robust log‑operation tools such as ELK, Prometheus, tracing systems to achieve effective observability.
This article introduces the most useful additions and modern replacements in recent Python releases—including pathlib, the secrets module, zoneinfo, dataclasses, proper logging, f‑strings, the built‑in tomllib, and the transition from distutils to setuptools—showing why and how to adopt them in everyday code.
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.
The article details the design and implementation of NEMichelinCache, a cross‑platform cache library for React Native and H5, explaining the problems of the legacy cache, the architectural choices made, the modules introduced, and the measurable improvements in stability and speed achieved after deployment.
This article explains what MDC (Mapped Diagnostic Context) is, outlines its API, demonstrates how to configure logging and interceptors, and provides concrete solutions—including a custom thread‑pool wrapper and HTTP client interceptors—to ensure TraceId is correctly propagated across threads and remote calls in Java backend systems.
Facing the challenges of distributed microservice architectures, a financial services company implemented a unified observability platform that combines metrics, tracing, and logging via OpenTelemetry and custom agents, enabling real‑time visualization, anomaly detection, and performance analysis across seven core business middle‑platforms.
The platform centralizes message‑center management for e‑commerce by adding end‑to‑end tracing, real‑time metrics, and unified logging, enabling business users to query message links, view dashboards, automate retries and approvals, dramatically reducing manual monitoring, improving completion rates above 90%, and paving the way for cost‑optimized, data‑driven operations.
This article explains why oversized logs hurt system performance, then presents a step‑by‑step methodology—including printing only necessary logs, merging duplicate entries, and simplifying payloads—illustrated with real Java code and a concrete case study that reduces daily log volume from 5 GB to under 1 GB.
This guide demonstrates how to modify Spring Boot 2.4.12 logger levels at runtime using LoggingSystem, enabling per‑package or whole‑application log level changes without editing configuration files or restarting the service.
This article explains how to design a flexible logging solution in Java by creating a custom @Log annotation, using meta‑annotations such as Retention and Target, and applying Spring AOP with various advice types to capture method parameters, return values, and notes without polluting service code.
The guide defines backend coding standards and best practices, specifying clear naming conventions for classes, methods, variables and constants, enforcing consistent code style via .editorconfig, recommending unchecked exceptions for simpler error handling, promoting structured asynchronous logging with trace IDs, and outlining performance optimizations such as loop refinement, CompletableFuture concurrency, and proper resource management to prevent memory leaks.
This article provides a detailed tutorial on using Spring Cloud Sleuth with Zipkin to monitor and troubleshoot distributed micro‑service calls, covering concepts, configuration, Maven dependencies, YAML settings, controller examples, RabbitMQ integration, logback adjustments, and alternative tracing solutions.
This article walks through the fundamentals of Linux log management by introducing Rsyslog, showing how to install it on CentOS, configure facilities and severity, and demonstrate practical examples for aggregating web server access logs to a central application server.
This article explains Docker and Kubernetes container logging fundamentals, highlights the limitations of default json‑file logging, and presents a unified log‑collection architecture using S6‑based images, filebeat, logrotate, Kafka, and Elasticsearch, with practical steps for dynamic configuration and log rotation in a k8s cluster.
Learn how to design robust, secure API interfaces by implementing signatures, encryption, IP whitelists, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, request size limits, load testing, asynchronous processing, data masking, and comprehensive documentation to ensure stability and safety.
This article explains how to enable detailed GC logging in the JVM, interpret both Young and Full GC log entries, configure heap parameters, and use the online visualizer gceasy.io to analyze performance metrics such as throughput, pause latency, and memory usage for effective JVM tuning.
This article outlines essential practices for building secure, reliable API interfaces—including request signing, data encryption, IP whitelisting, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, payload limits, performance testing, asynchronous processing, data masking, and comprehensive documentation—to help developers meet safety, stability, and maintainability requirements.
This article introduces Grafana Tempo, its integration with Grafana, Prometheus, Loki, and the new TraceQL query language, explaining how they provide a lightweight, scalable tracing solution for small‑to‑medium teams and enhance observability through powerful, data‑type‑aware queries.
This article explains how MySQL's InnoDB engine guarantees ACID properties by describing the four components of ACID, the four isolation levels, lock granularity and types, the MVCC mechanism with version chains and read views, and the roles of undo, redo, and bin logs in ensuring atomicity, consistency, isolation, and durability.
The brief explains how Lombok’s @Builder can clash with JSON libraries and how adding no‑args and all‑args constructors resolves it, shows how to adjust log levels at runtime via Arthas or Spring’s LoggingSystem, outlines JWT structure and security cautions, and warns of common Java 8 parallelStream performance and correctness pitfalls.
This guide explains the roles of Elasticsearch, Logstash, and Kibana in a logging pipeline and provides a complete Docker‑Compose configuration along with commands to launch and manage the ELK services for full‑text search and visual analysis of application logs.
This article explains how to use SLF4J's MDC to attach a request identifier to log entries, demonstrates the limitation of MDC in asynchronous threads, and provides a decorator‑pattern solution (MDCRunnable) that propagates the context, enabling reliable log correlation across threads in Java backend applications.
This article presents a comprehensive guide on designing a unified JSON response structure, implementing global exception handling with @ControllerAdvice, and configuring Logback for console and file logging in Spring Boot applications, complete with code examples and best‑practice recommendations.
This tutorial explains how Spring Boot handles logging with Commons Logging, demonstrates using SLF4J as a facade, shows a complete code example, and covers configuring log output, levels, color, file rotation, and custom patterns for effective backend logging.
PostgreSQL 15, released on October 13 2022, brings major performance gains such as faster sorting and WAL compression, adds the SQL MERGE command, expands regex and multirange support, improves security with security_invoker, and enhances logical replication, logging, and configuration flexibility for modern data workloads.
This tutorial explains how to set up Graylog for centralized log aggregation using Docker Compose, configure its inputs, and integrate a Spring Boot application with Graylog via Logback GELF, including search syntax examples for effective log analysis.
This article explains how to build a Spring Cloud‑based microservice framework and add full‑stack log traceability by generating a traceId, propagating it via MDC and interceptors, and visualizing the linked logs through ELK, covering both intra‑process and inter‑service scenarios.
This article explains how to integrate Logback with SLF4J in Spring Boot, covering dependency setup, default and custom configurations via logback‑spring.xml, detailed element descriptions, and best‑practice logging code examples, including file rolling policies and performance considerations.
This tutorial demonstrates how to deploy an ELK Stack (Elasticsearch, Logstash, Kibana, and Filebeat) using Docker, covering offline image loading, IK analyzer setup, production‑grade configurations, multiline plugin installation, log generation, and troubleshooting in a single‑machine environment.
This article walks through the evolution of an online supermarket from a simple monolithic web app to a fully fledged microservice architecture, detailing the motivations, design decisions, component breakdown, common pitfalls, and essential practices such as monitoring, tracing, logging, service discovery, resilience patterns, testing, and the role of service meshes.
Effective logging is essential for debugging, performance monitoring, and compliance, and this guide explains why developers should adopt good logging habits, outlines key log purposes, requirements for readability, performance, storage, timeliness, levels, content, and format, and provides concrete Log4j examples and code snippets.
This guide explains why Logback is the preferred logging framework for Spring Boot, shows how to add the necessary dependencies, configure console and file appenders, customize log patterns, use rolling policies, apply filters, and optimize logging statements with placeholders, all illustrated with clean XML and Java code examples.
This guide compares three log‑collection methods—SLS, NAS, and Kafka—available in Alibaba Cloud Serverless App Engine, explaining their architectures, ideal use cases, configuration details, and how to avoid common pitfalls such as log loss and rotation issues.
This article explains why oversized logs hurt system performance, presents three practical log‑shrinking strategies—printing only necessary logs, merging duplicate entries, and simplifying content—illustrates them with Java code snippets, and evaluates their impact through a real‑world case that cuts daily log volume from 5 GB to under 1 GB.
To diagnose and resolve Redis slow queries, this guide explains how to retrieve and manage the slow query log, understand command complexities, replace inefficient commands with optimized alternatives, and configure slowlog settings such as slowlog‑max‑len and slowlog‑log‑slower‑than for production environments.
This article explains how Fluentd works in distributed and containerized environments, walks through its core concepts of input, filter, and output plugins, and provides a step‑by‑step Docker demo that collects, filters, parses, and stores Kubernetes application logs for further analysis.
This article shares practical development techniques, including how to safely commit Kafka messages within transactions, simplify Redis distributed locks with Redisson, implement an AOP‑based lock annotation for method-level locking, and decouple business logging using asynchronous thread pools and helper utilities.
This article explains why logging is essential for maintainable software, outlines best‑practice guidelines for readable, performant, and secure log output, and details Log4j components, log level hierarchy, and practical macro examples for each level.
This article explains why proper logging is essential for software maintenance, outlines the purposes of logs, describes the requirements for readable, performant, and space‑efficient log output, and details Log4j components, log‑level hierarchy, and concrete code examples for TRACE, INFO, DEBUG, WARN, and ERROR logging.
The article examines how Log4j2’s AsyncAppender can block threads when its default 128‑entry queue fills, because creating LogEvent snapshots triggers ThrowableProxy parsing that loads reflective and lambda‑generated classes, causing class‑loader bottlenecks, and recommends custom async appenders, disabling reflection inflation, using synchronous loggers, and proper configuration to avoid these delays.
This article explains the importance of proper logging in software, outlines common logging requirements such as readability, performance, disk usage, and timeliness, and details Log4j components, log level definitions, hierarchy, recommended usage, and provides concrete macro and log‑statement examples.
This article discusses practical methods for reducing log volume in backend applications, including printing only necessary logs, merging log entries, simplifying messages, and applying these techniques in a real-world Java case to shrink daily log size from several gigabytes to under one gigabyte while preserving debugging capability.
This article introduces a Logback desensitization component for Java applications, explains two common masking approaches, compares their pros and cons, and provides step‑by‑step instructions—including Maven dependency, appender replacement, YAML configuration, supported data types, matching rules, custom regex, and jar installation—to securely mask sensitive information in logs.
This article explains what MDC (Mapped Diagnostic Context) is, outlines its API and advantages, demonstrates common traceId loss problems in child threads and HTTP calls, and provides practical solutions including thread‑pool wrappers, MDC utilities, and interceptors for HttpClient, OkHttp, RestTemplate, and third‑party services, plus the required log pattern.
This article introduces Loki, Grafana Labs' open‑source, horizontally scalable log aggregation system, compares it with ELK/EFK, explains its architecture and components, and provides step‑by‑step deployment instructions with Promtail configuration and Grafana integration for Kubernetes environments.
This article introduces Rust's log4rs library, explains its core concepts of appenders and loggers, and provides complete code examples for configuring system and business log files, initializing the logger, and handling command‑line log commands in a Rust application.
The article explains how AsyncAppender uses a BlockingQueue with a default size of 256, how an oversized queue can cause OOM, how the discardingThreshold can lead to loss of TRACE/DEBUG/INFO logs, and provides configuration tips such as adjusting queueSize, setting discardingThreshold to zero, or enabling neverBlock to avoid blocking.
This article introduces a lightweight Java logging utility class named LogUtils that supports four log levels, formats messages, and can output logs to the console or a file, with configurable level, target, and file settings, accompanied by example usage code.
This guide explains how to configure and read Nginx access and error logs, covering log format definitions, file locations, log level settings, and practical commands for parsing log entries to troubleshoot server and application issues.
This article presents 36 practical guidelines for backend engineers covering interface parameter validation, compatibility, extensibility, idempotency, logging, error handling, security, rate limiting, caching, transaction management, and more, helping you design reliable, maintainable, and high‑performance APIs across any language.
This article outlines practical techniques for handling online services with QPS exceeding 200,000, including avoiding relational databases, employing multi‑level caching, leveraging multithreading, implementing degradation and circuit‑breaker patterns, optimizing I/O, using controlled retries, handling edge cases, and logging efficiently.
This guide introduces the ELK stack (Elasticsearch, Logstash, Kibana, and Filebeat), explains why centralized log management is essential, details the architecture options, and provides step‑by‑step installation and configuration instructions—including a Kafka‑backed pipeline—to help you deploy a production‑grade logging solution.
This guide compares three ELK deployment architectures—Logstash‑only, Filebeat‑assisted, and cache‑queue‑enhanced—explains their trade‑offs, and provides concrete Logstash/Filebeat multiline, timestamp, and module‑filtering configurations to address typical logging problems.
The article explains Go’s built‑in error interface, distinguishes errors, exceptions and panics, presents three handling patterns—classic returns, stateful objects, and functional deferred execution—shows how to wrap errors for context, and demonstrates using the errgroup concurrency primitive (including an extended version) for safe parallel processing.
This article introduces the Tenacity Python library, explains how to install it, and demonstrates various retry strategies such as unlimited retries, stopping after success, limiting attempts or time, combining stop conditions, setting fixed or random wait intervals, and adding pre‑ and post‑retry logging with complete code examples.
This article explains why proper logging is essential for software maintenance, outlines the purposes of logs, details best‑practice requirements such as readability, performance impact, disk usage and timeliness, and provides a comprehensive guide to Log4j components, log levels, their hierarchy, and practical code examples for each level.
This guide walks you through setting up distributed logging for microservices using Spring Cloud Sleuth for tracing, Zipkin as the tracing server, and the ELK stack for log collection and visualization, covering configuration, code examples, and log querying.
Learn how to configure and read Nginx access and error logs, including defining log formats, setting file locations, customizing log levels, parsing log fields, and using command‑line tools to monitor logs in real time, with practical examples and best‑practice recommendations.
This article describes how a high‑throughput push notification system was enhanced with a dedicated testability metric, introducing tools such as a test‑sending UI, dual synchronous‑asynchronous API handling, a reachability diagnostic utility, and end‑to‑end unique‑ID logging to streamline debugging and reduce maintenance costs.
The article explains the rising importance of observability in modern operations, defines its control‑theory roots, breaks it down into metrics, traces and logs, and argues that successful implementation requires three pillars—SRE practices, AIOps algorithms, and deep business‑architecture knowledge—together with well‑designed SLOs and critical‑path mapping.
This article explains what MDC (Mapped Diagnostic Context) is, shows its API and advantages, demonstrates how to add interceptors and log patterns to include a traceId, and provides solutions for traceId loss in child threads and HTTP calls by wrapping thread pools and implementing HTTP client interceptors.
This article explains how to create a Spring Boot AOP request‑logging aspect that captures request parameters, execution time, results, and errors, while also adding trace‑ID support for easier debugging in high‑concurrency environments.
This article explains how to create the open‑source pm2-intercom-log4js tool to reliably synchronize log4js output in PM2’s multi‑process mode, covering log4js’s sync mechanism, PM2 process management, IPC communication, and alternative messaging approaches with practical code examples.
Observability is more than just combining metrics, traces, and logs; successful implementation requires the disciplined SRE methodology, AI‑driven AIOps capabilities, and a deep understanding of business architecture to define critical paths and layered SLOs for real‑world systems.
This article examines fifteen common Java pitfalls and best‑practice guidelines—ranging from property copying and date formatting to HashMap sizing, thread‑pool creation, collection handling, logging, and serialization—explaining why each recommendation exists and how it impacts performance and safety.
This guide explains how to create a custom annotation and an Aspect in Spring to capture detailed operation logs—including description, table name, parameters, user info, and execution result—and persist them to a database, covering AOP terminology, configuration styles, and complete code examples.
This article recounts NetEase's journey from early host‑based log collection to operator‑driven Kubernetes logging, discusses the challenges of large‑scale log ingestion, evaluates existing agents, and introduces the open‑source Loggie project with its architecture, features, performance gains, and roadmap.
The article explains why unified log structures and traceId identifiers are essential for quickly locating bugs in high‑traffic backend services, provides a Java LogObject example, demonstrates chain‑style setters, shows how to combine request and response in one log entry, and compares manual logging with AOP‑based approaches for performance and maintainability.
This article explains how to build a comprehensive monitoring system for both infrastructure and applications, introducing the USE (Utilization‑Saturation‑Errors) method, key performance metrics, and practical components such as Prometheus, Grafana, full‑link tracing, and the ELK stack to detect and diagnose performance bottlenecks.
This article explains what MDC is, its API, common pitfalls like traceId loss in child threads and HTTP calls, and provides practical solutions using custom thread pool wrappers and interceptors for HttpClient, OkHttp, and RestTemplate to reliably propagate trace identifiers.
This guide explains why Apache-related logs appear in the console when integrating Tinylog with Spring Boot and shows how to hide them by setting the appropriate logging level for the offending package, such as disabling org.apache.catalina logs.
JetBrains announced that the IntelliJ platform will discontinue Log4j usage, recommending java.util.logging as the standard logging framework, and provides detailed migration steps, security reasons, and version information for developers to adapt their plugins and dependencies.
This article investigates whether the Mapped Diagnostic Context (MDC) in Java logging can lead to memory leaks by analyzing its ThreadLocal implementation, running multiple thread‑pool scenarios, and comparing the findings with classic ThreadLocal leak cases.
This guide provides a comprehensive overview of the Tars microservice framework, covering its core concepts, deployment methods across various environments, configuration management, service discovery, logging, monitoring, and operational features such as gray releases and circuit‑breaker strategies.
This guide explains how to configure Python's logging.handlers.SMTPHandler to email log messages, why QQ enterprise and Gmail require SSL instead of TLS, and provides a complete logging.conf example with sample code to avoid common pitfalls.
This article explains how to monitor, collect, and analyze real‑time logs, use multi‑dimensional metrics, perform local debugging, and enable cloud‑edge debugging for Spring Boot applications running on a Serverless platform, providing step‑by‑step commands and visual guides.
This article explains how to design and implement a terabyte‑level log monitoring platform using ELK Stack, FileBeat, Elastic APM, Kafka Streams, Prometheus, and Grafana, covering data collection, filtering, visualization, and resource‑efficient processing for large‑scale microservice environments.
This article explains the concept of MDC (Mapped Diagnostic Context) in Java logging, details its API, demonstrates how to propagate traceId across threads and HTTP calls using interceptors and custom thread‑pool wrappers, and shows how to configure log patterns to include the traceId.
Learn how to replace Spring Boot 2.x's default Logback logging with the high‑performance Log4j2 by adding the starter dependency, configuring the logging file, and setting up a basic log4j2.xml, including code snippets and troubleshooting tips for a smooth migration.
This guide explains how Spring Boot handles logging through Commons Logging, recommends using SLF4J as a facade, shows code examples, details log elements, demonstrates how to enable DEBUG, configure console colors, file output, rolling policies, level control, and custom formats for effective backend logging.
This article explains how to create a custom logging solution in Spring by defining annotation-based AOP aspects, configuring pointcuts, handling various advice types, and persisting log details such as user, operation, parameters, and results into a database using Java code examples.
This article explains how to configure Python's logging.handlers.SMTPHandler to send log messages via email, addresses common authentication timeout issues with QQ corporate mail by using TLS/SSL connections, and provides a complete logging.conf example with a test script.
This guide explains how to create a custom Spring AOP logging solution by defining a @SystemCrmlog annotation, extracting its parameters via pointcuts, and persisting detailed log entries—including user, method, parameters, and execution results—to a database using aspect advice methods.
This article explains Docker and Kubernetes logging challenges, compares logging drivers, and presents a unified, node‑agent based logging architecture using S6‑based containers, Filebeat, logrotate, Kafka, and Elasticsearch to achieve reliable, auto‑rotating log collection in production environments.
Apache Log4j 2.17.0 has been released, addressing CVE‑2021‑45105 and fixing recursive string‑replacement vulnerabilities that could cause StackOverflowError DoS attacks, while also tightening JNDI usage and correcting several configuration and appender issues, with recommended mitigation steps for earlier versions.
Apache Log4j 2.16.0 has been released, offering updated SLF4J adapters, disabling JNDI by default to mitigate CVE‑2021‑44228, removing message lookups, and requiring Java 8+, with detailed upgrade instructions and links to download and issue trackers.
This article introduces MDC, explains its API and advantages, and provides practical solutions for traceId propagation in multithreaded environments, HTTP calls, and custom thread pools using Java logging frameworks such as Log4j, Logback, and Log4j2.
This article explains what MDC is, the problems it faces such as traceId loss in child threads and HTTP calls, and provides concrete solutions including interceptor implementation, thread‑pool wrappers, and logging pattern adjustments to ensure reliable traceId propagation in Java backend services.
This article explains how to use SLF4J's MDC feature to attach a request ID to log entries, enabling fast filtering of all logs belonging to a single request even across asynchronous threads and thread pools, and shows a decorator‑based solution for proper propagation.
This article explains how to add a base controller method in ThinkPHP6 that detects search engine spider user‑agents, builds the request URL, obtains the real client IP, and stores the spider name, URL, and IP into a BaiduLog model for logging purposes.
This article breaks down the widely publicized Log4j2 (Log4Shell) flaw, explaining the underlying JNDI and LDAP lookup mechanisms, how malicious payloads are executed through log messages, the massive impact across Java ecosystems, and the steps needed to remediate the issue.
This article explains why multiple Java logging frameworks often clash in SpringBoot and Dubbo applications, identifies common causes such as transitive dependencies and duplicate versions, and provides step‑by‑step Maven configurations and adaptation techniques to unify logging with SLF4J and Logback.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing to effective logging, Git mastery, prioritizing functionality, handling ambiguous requirements, proactive problem‑solving, scheduling buffers, hands‑on learning, and improving English for better access to technical resources.
This guide explains how to use Filebeat to ship logs to Graylog, covering Filebeat's architecture, configuration files, deployment options with Docker or native packages, Graylog's components and pipelines, and step‑by‑step Docker‑compose setup for a scalable centralized logging solution.
During the COVID‑19 surge, web traffic spiked dramatically, prompting a detailed guide on five practical Nginx configuration changes—enabling Gzip compression, setting cache headers, activating HTTP/2, streamlining logging, and limiting bandwidth—to dramatically reduce bandwidth usage and improve site responsiveness.
