BestHub
Sign in
Tagged articles
692 articles
Page 5 of 7
MaGe Linux Operations
MaGe Linux Operations
Nov 16, 2021 · Backend Development

Why Loguru Beats Python’s Built‑in Logging: A Hands‑On Guide

This article introduces Loguru, a third‑party Python logging library, explains why it simplifies logging compared to the standard logging module, outlines its key features such as out‑of‑the‑box setup, async safety, lazy evaluation, and file rotation, and provides practical code examples for quick integration into scripts, libraries, and frameworks.

AsyncLogurudebugging
0 likes · 11 min read
Why Loguru Beats Python’s Built‑in Logging: A Hands‑On Guide
21CTO
21CTO
Nov 9, 2021 · Backend Development

Mastering Elegant Operation Log Design with AOP and SpEL in Java

This article explains how to implement clean, decoupled operation logs in Java applications using AOP, SpEL, custom annotations, and dynamic templates, covering use cases, implementation methods, code examples, parsing logic, context handling, and integration with Spring Boot.

Operation LogSpELaop
0 likes · 27 min read
Mastering Elegant Operation Log Design with AOP and SpEL in Java
Python Programming Learning Circle
Python Programming Learning Circle
Oct 23, 2021 · Backend Development

Using Loguru for Simplified and Powerful Python Logging

This article introduces the Loguru library as an elegant, concise alternative to Python's built‑in logging, demonstrating installation, basic usage, file configuration, formatting, filtering, rotation, retention, compression, serialization, and advanced exception tracing with code examples.

Exception HandlingLogurulogging
0 likes · 17 min read
Using Loguru for Simplified and Powerful Python Logging
Efficient Ops
Efficient Ops
Oct 17, 2021 · Cloud Native

From Zero to Production: Building an Enterprise‑Grade Kubernetes Architecture

This article chronicles a recent graduate’s year‑long journey mastering cloud‑native technologies, detailing the design and implementation of a multi‑cluster Kubernetes architecture, unified logging, CI/CD pipelines, service governance with Istio, and private deployment strategies for a 3D editor platform.

Cloud NativeDevOpsci/cd
0 likes · 12 min read
From Zero to Production: Building an Enterprise‑Grade Kubernetes Architecture
Python Programming Learning Circle
Python Programming Learning Circle
Oct 16, 2021 · Backend Development

Loguru: An Elegant Python Logging Library – Features, Usage, and Integration

This article introduces Loguru, a powerful third‑party Python logging library, explains why it simplifies logging compared to the standard logging module, outlines its key features such as out‑of‑the‑box setup, asynchronous support, lazy evaluation, and structured logging, and provides practical code examples and integration tips for scripts, libraries, and Flask applications.

LibraryLogurulogging
0 likes · 12 min read
Loguru: An Elegant Python Logging Library – Features, Usage, and Integration
Java Backend Technology
Java Backend Technology
Oct 10, 2021 · Backend Development

15 Essential Logging Practices Every Java Backend Engineer Should Follow

Effective logging is crucial for debugging and accountability; this guide presents fifteen practical recommendations—from selecting appropriate log levels and formatting to using SLF4J, asynchronous output, and avoiding common pitfalls—designed to help Java developers write clear, performant, and maintainable logs.

logbackloggingperformance
0 likes · 12 min read
15 Essential Logging Practices Every Java Backend Engineer Should Follow
Programmer DD
Programmer DD
Sep 30, 2021 · Operations

How to Build a Scalable Kubernetes Log Collection System with S6 and Filebeat

This article explains the limitations of Docker's default JSON‑file logging, introduces S6‑based container log redirection, compares Kubernetes logging approaches at pod, node, and cluster levels, and presents a full‑stack architecture using Filebeat, Kafka, Elasticsearch, and Logstash for reliable, rotatable log collection.

DockerFilebeatKubernetes
0 likes · 8 min read
How to Build a Scalable Kubernetes Log Collection System with S6 and Filebeat
Liangxu Linux
Liangxu Linux
Sep 28, 2021 · Fundamentals

Where Does printk Output Go? A Complete Guide to Linux Kernel Logging

This article explains how the Linux kernel's printk function stores messages in a ring buffer, how those messages are exposed to user space via dmesg, /proc/kmsg, klogctl, and the system console, and why understanding this flow is crucial for developers and operators.

Linuxdmesglogging
0 likes · 10 min read
Where Does printk Output Go? A Complete Guide to Linux Kernel Logging
Efficient Ops
Efficient Ops
Sep 26, 2021 · Cloud Native

How to Stabilize Your Kubernetes Clusters: CI/CD, Monitoring, Logging, and Docs

This article analyzes why our Kubernetes clusters were constantly unstable—citing an erratic release process, missing monitoring, logging, documentation, and unclear request routing—and presents a comprehensive solution that includes a Kubernetes‑centric CI/CD pipeline, federated monitoring, centralized logging, a documentation hub, and integrated traffic management.

Cloud NativeDevOpsci/cd
0 likes · 8 min read
How to Stabilize Your Kubernetes Clusters: CI/CD, Monitoring, Logging, and Docs
Top Architect
Top Architect
Sep 24, 2021 · Cloud Native

Loki Log System Overview, Architecture, and Deployment Guide

This article introduces Loki, a lightweight log aggregation system for Kubernetes, explains its background and motivations, details its simple architecture and core components (Distributor, Ingester, Querier), discusses scalability and storage options, and provides step‑by‑step deployment instructions with example YAML and shell commands.

Cloud NativeDeploymentKubernetes
0 likes · 16 min read
Loki Log System Overview, Architecture, and Deployment Guide
macrozheng
macrozheng
Sep 24, 2021 · Backend Development

15 Essential Logging Practices to Debug Faster and Avoid Blame

This article presents 15 practical logging best‑practice recommendations for Java developers, covering log level selection, formatting, conditional logging, performance‑friendly placeholders, asynchronous output, proper exception handling, and log file organization to improve debugging efficiency and maintainable production systems.

best practicesdebugginglogback
0 likes · 11 min read
15 Essential Logging Practices to Debug Faster and Avoid Blame
IT Architects Alliance
IT Architects Alliance
Sep 21, 2021 · Cloud Native

Improving Cluster Stability: CI/CD, Monitoring, Logging, Documentation, and Request Routing Solutions

The article analyzes the instability of a company's Kubernetes clusters, identifies root causes such as an unstable release process, lack of monitoring, logging, documentation, and unclear request routing, and proposes comprehensive solutions including a Kubernetes‑centric CI/CD pipeline, a federated Prometheus monitoring platform, an Elasticsearch logging system, a centralized documentation hub, and a unified traffic management architecture.

Documentationci/cdlogging
0 likes · 8 min read
Improving Cluster Stability: CI/CD, Monitoring, Logging, Documentation, and Request Routing Solutions
IT Architects Alliance
IT Architects Alliance
Sep 20, 2021 · Operations

Why Loki Beats ELK for Kubernetes Logging: Architecture and Deployment Guide

This article explains the motivations behind choosing Loki over ELK for container‑cloud logging, details Loki's lightweight architecture—including Distributor, Ingester, and Querier components—covers deployment steps on OpenShift/Kubernetes with YAML manifests, and demonstrates LogQL query syntax for efficient log retrieval.

KubernetesLogQLLoki
0 likes · 18 min read
Why Loki Beats ELK for Kubernetes Logging: Architecture and Deployment Guide
IT Architects Alliance
IT Architects Alliance
Sep 20, 2021 · Backend Development

Design and Implementation of a Custom Java Logging Framework

This article walks through building a complete Java logging framework from scratch, covering the core LoggingEvent class, Appender abstraction, Level enumeration, hierarchical Logger design, context management, factory creation, and XML/YAML configuration parsing.

AppenderConfigurationFramework
0 likes · 14 min read
Design and Implementation of a Custom Java Logging Framework
Meituan Technology Team
Meituan Technology Team
Sep 16, 2021 · Backend Development

Elegant Operation Log Recording in Backend Systems Using AOP and Annotations

The article demonstrates how to implement elegant, business‑logic‑independent operation logging in Java back‑ends by using AOP‑driven annotations, SpEL dynamic templates, custom parse functions, thread‑local context, and a Spring Boot starter, offering flexible persistence and automatic operator retrieval.

BackendOperation Logannotation
0 likes · 27 min read
Elegant Operation Log Recording in Backend Systems Using AOP and Annotations
Ops Development Stories
Ops Development Stories
Sep 16, 2021 · Cloud Native

Master Kubernetes: A Step‑by‑Step Learning Roadmap for Beginners

This guide walks beginners through a structured learning path for Kubernetes, covering fundamentals, core components, key objects, controllers, storage, networking, resource management, security, cluster operations, backup, logging, monitoring, DevOps practices, and deeper topics like architecture, source code, and operator development.

BackupCloud NativeDevOps
0 likes · 16 min read
Master Kubernetes: A Step‑by‑Step Learning Roadmap for Beginners
dbaplus Community
dbaplus Community
Sep 13, 2021 · Operations

How to Stabilize a Failing Kubernetes Cluster: CI/CD, Monitoring, Logging, and Docs

This article analyzes why a company's Kubernetes clusters were constantly on the brink of failure and presents a comprehensive solution covering CI/CD pipeline reconstruction, federated monitoring with Prometheus, centralized logging via Elasticsearch, documentation centralization, and clarified request routing to achieve high reliability.

Kubernetesci/cdcluster stability
0 likes · 9 min read
How to Stabilize a Failing Kubernetes Cluster: CI/CD, Monitoring, Logging, and Docs
Baidu Intelligent Testing
Baidu Intelligent Testing
Sep 9, 2021 · Cloud Native

Observability Practices in Baidu Search Platform: Real‑time Metrics, Tracing, Logging, and Topology at Hundred‑Billion Scale

This article explains how Baidu's search middle‑platform adopts cloud‑native observability—covering metrics, distributed tracing, log querying, and topology analysis—to ensure high availability, performance, and controllability for a system handling hundreds of billions of requests across millions of micro‑service instances.

loggingobservabilitytopology
0 likes · 12 min read
Observability Practices in Baidu Search Platform: Real‑time Metrics, Tracing, Logging, and Topology at Hundred‑Billion Scale
IT Architects Alliance
IT Architects Alliance
Sep 8, 2021 · Operations

How to Build a Real‑Time ELK Log Analysis Platform on Ubuntu

This step‑by‑step guide explains how to set up the open‑source ELK stack (Elasticsearch, Logstash, Kibana) on an Ubuntu machine, configure Logstash as shipper and indexer, integrate Spring Boot and Nginx logs, and run the whole platform as a background service using Supervisor.

ELKElasticsearchKibana
0 likes · 19 min read
How to Build a Real‑Time ELK Log Analysis Platform on Ubuntu
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 5, 2021 · Cloud Native

From Rookie to Cloud‑Native Architect: Building an Enterprise Kubernetes Cluster

Over the past year, the author chronicles a hands‑on journey from a fresh graduate to a cloud‑native specialist, detailing the design and implementation of an enterprise‑grade Kubernetes architecture—including multi‑cluster logging, CI/CD pipelines, Istio service mesh, monitoring, and private‑deployment strategies—while sharing practical lessons learned.

Cloud NativeKubernetesService Mesh
0 likes · 13 min read
From Rookie to Cloud‑Native Architect: Building an Enterprise Kubernetes Cluster
Top Architect
Top Architect
Sep 4, 2021 · Backend Development

Understanding Spring Boot Default Logging Configuration and Customization

This article explains Spring Boot's default logging setup using SLF4J and Logback, demonstrates how to view log levels in a test class, shows how to modify log levels via application properties, and details the underlying XML configuration files and how to customize them for different environments.

Spring Bootbackend-developmentjava
0 likes · 13 min read
Understanding Spring Boot Default Logging Configuration and Customization
Top Architect
Top Architect
Sep 2, 2021 · Cloud Native

Designing a Stable Backend Architecture: CI/CD, Federated Monitoring, Logging, Documentation, and Traffic Management on Kubernetes

The article analyzes why a company's clusters were unstable—unstable release process, missing monitoring and logging, insufficient documentation, and unclear request routing—and proposes a comprehensive solution built around Kubernetes‑centric CI/CD, a federated Prometheus monitoring platform, Elasticsearch logging, centralized documentation, and Kong/Istio traffic management.

Backend ArchitectureCloud NativeDocumentation
0 likes · 9 min read
Designing a Stable Backend Architecture: CI/CD, Federated Monitoring, Logging, Documentation, and Traffic Management on Kubernetes
Node Underground
Node Underground
Aug 15, 2021 · Backend Development

Mastering Node.js Logging: Active vs Passive Techniques and Best Practices

This article explores effective logging strategies in Node.js, comparing active console output with passive library-based recording, introducing popular modules such as debug and util.debuglog, detailing log format components, and demonstrating context-aware logging implementations to improve debugging and operational monitoring.

Node.jscontext loggingdebug
0 likes · 10 min read
Mastering Node.js Logging: Active vs Passive Techniques and Best Practices
MaGe Linux Operations
MaGe Linux Operations
Aug 14, 2021 · Operations

Boost System Reliability: 4 Proven Practices to Master Observability

This article explains why observability is essential for DevOps, outlines four key practices—including production‑environment monitoring, structured logging, a DevOps‑focused culture, and pre‑deployment observability with remote debugging—to help teams detect, diagnose, and prevent issues throughout the software lifecycle.

CultureDevOpsci/cd
0 likes · 9 min read
Boost System Reliability: 4 Proven Practices to Master Observability
Efficient Ops
Efficient Ops
Aug 5, 2021 · Operations

Deploy ELK Stack with Docker on Windows 10 VM: Step‑by‑Step Guide

Learn how to quickly set up the ELK stack (Elasticsearch, Logstash, Kibana) using Docker on a Windows 10 VirtualBox VM, configure Filebeat, and verify log collection and visualization, with detailed commands, configuration files, and troubleshooting tips for a complete operational experience.

DockerELKlogging
0 likes · 10 min read
Deploy ELK Stack with Docker on Windows 10 VM: Step‑by‑Step Guide
Code Ape Tech Column
Code Ape Tech Column
Jul 31, 2021 · Backend Development

Understanding Log4j2 RollingFileAppender: Configuration, Policies, and Strategies

This article explains how Log4j2's RollingFileAppender works, covering the concepts of rollover, the various TriggeringPolicy options, DefaultRolloverStrategy behavior, DeleteAction configuration, and provides sample XML configurations and a Java demo to illustrate time‑based, size‑based, and composite rollover scenarios.

ConfigurationRollingFilejava
0 likes · 13 min read
Understanding Log4j2 RollingFileAppender: Configuration, Policies, and Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Jul 22, 2021 · Operations

Observability in Serverless Environments: Monitoring, Logging, Distributed Tracing, and Best Practices

In this talk, Gal Bashan explains how serverless architectures complicate observability and why metrics, logs, and especially distributed tracing with tools like OpenTelemetry, Jaeger, or commercial platforms are essential for gaining end-to-end visibility, automating instrumentation, and maintaining reliable, business-focused services across cloud providers.

Cloud NativeDistributed TracingServerless
0 likes · 12 min read
Observability in Serverless Environments: Monitoring, Logging, Distributed Tracing, and Best Practices
Laravel Tech Community
Laravel Tech Community
Jul 21, 2021 · Operations

Optimizing Nginx Performance: Gzip Compression, Cache Headers, HTTP/2, Logging, and Bandwidth Limiting

This article explains practical Nginx configuration tweaks—including enabling gzip compression, setting cache headers, activating HTTP/2, optimizing logging, and limiting bandwidth—to reduce bandwidth usage and server load, illustrated with code examples and performance impact calculations for typical web traffic.

GzipHTTP/2bandwidth limiting
0 likes · 9 min read
Optimizing Nginx Performance: Gzip Compression, Cache Headers, HTTP/2, Logging, and Bandwidth Limiting
Ops Development Stories
Ops Development Stories
Jul 20, 2021 · Cloud Native

How to Build a Production‑Ready ELK Logging Stack on Kubernetes

This guide walks through the concepts of ELK, why log management is essential for Kubernetes, three collection strategies, required log fields, and step‑by‑step deployment of Elasticsearch, Kibana, Filebeat, and Logstash—including YAML manifests, configuration snippets, and Kibana UI setup—for a fully operational, cloud‑native logging solution.

Cloud NativeELKFilebeat
0 likes · 26 min read
How to Build a Production‑Ready ELK Logging Stack on Kubernetes
Tencent Cloud Middleware
Tencent Cloud Middleware
Jul 13, 2021 · Backend Development

Why Kratos Is the Go Microservice Framework You Need: Protobuf, DI, and OpenTelemetry Explained

This article introduces the lightweight Go microservice framework Kratos, covering its Protobuf‑driven API design, open and extensible architecture, logging and tracing integrations, functional‑option configuration, unified error model, and compile‑time dependency injection with code examples and diagrams.

GoKratosMicroservices
0 likes · 18 min read
Why Kratos Is the Go Microservice Framework You Need: Protobuf, DI, and OpenTelemetry Explained
Top Architect
Top Architect
Jul 11, 2021 · Backend Development

Implementing Request Logging with Spring AOP: A Practical Guide

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures request parameters, response data, execution time, and error information, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

aopaspectjjava
0 likes · 12 min read
Implementing Request Logging with Spring AOP: A Practical Guide
Python Programming Learning Circle
Python Programming Learning Circle
Jul 8, 2021 · Fundamentals

Rich Python Library: Rich Text and Formatting for the Terminal – Installation, Usage, and Features

This article introduces the Rich Python library, explains its cross‑platform compatibility, provides step‑by‑step installation instructions, demonstrates how to use its enhanced print, console, logging, table, progress bar, column, markdown, and syntax‑highlighting features, and includes numerous code examples and screenshots.

consoleformattinglogging
0 likes · 8 min read
Rich Python Library: Rich Text and Formatting for the Terminal – Installation, Usage, and Features
Java High-Performance Architecture
Java High-Performance Architecture
Jul 6, 2021 · Backend Development

How to Implement Fine‑Grained Operation Logging in Spring Boot with BizLog SDK

This article explains how the BizLog component records who performed which action at what time in Spring Boot applications, covering Maven setup, annotation usage, custom operators, detail fields, category segregation, SpEL expressions, custom parse functions, and extension points for persistence and operator retrieval.

BizLogSpring Bootannotation
0 likes · 16 min read
How to Implement Fine‑Grained Operation Logging in Spring Boot with BizLog SDK
Ops Development Stories
Ops Development Stories
Jun 30, 2021 · Cloud Native

Mastering Kubernetes: Essential Node & Pod Practices for Stable, Secure Deployments

This article outlines essential Kubernetes operational practices—including node maintenance, kernel upgrades, Docker and kubelet tuning, pod resource limits, scheduling strategies, health probes, logging standards, and monitoring setups—to ensure applications run reliably, securely, and efficiently in production environments.

Cloud NativeKubernetesNode Management
0 likes · 18 min read
Mastering Kubernetes: Essential Node & Pod Practices for Stable, Secure Deployments
Architect's Tech Stack
Architect's Tech Stack
Jun 26, 2021 · Backend Development

Retrofit Spring Boot Starter – A Lightweight HTTP Client Integration for Spring Boot

The article introduces retrofit‑spring‑boot‑starter, a lightweight HTTP client framework for Spring Boot that simplifies HTTP request management by integrating Retrofit with features such as custom OkHttpClient injection, annotation‑driven interfaces, global and path‑based interceptors, retry logic, logging, circuit‑breaker support, connection‑pool configuration, and flexible call‑adapter and converter factories.

HTTP clientRetrofitRetry
0 likes · 21 min read
Retrofit Spring Boot Starter – A Lightweight HTTP Client Integration for Spring Boot
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 18, 2021 · Frontend Development

Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging

To boost iQIYI’s front‑end reliability, the team replaced a Velocity‑based SSR with Nuxt, introduced a centralized page‑config plugin, streamlined legacy‑browser handling, built a visual data‑filtering API, implemented Nginx and component caching, purge endpoints, multi‑layer rate limiting, disaster‑recovery fallback, and comprehensive logging, achieving ~0.5 s first‑screen loads, 0.2 % error rate and near‑100 % availability.

NuxtSSRlogging
0 likes · 19 min read
Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging
Top Architect
Top Architect
Jun 16, 2021 · Backend Development

Implementing Request Logging with Spring AOP: Aspect Code and Best Practices

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.

Request Loggingaopaspectj
0 likes · 12 min read
Implementing Request Logging with Spring AOP: Aspect Code and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Jun 10, 2021 · Backend Development

Understanding Log4j2 RollingFile Appender: TriggeringPolicy, RolloverStrategy, and DeleteAction

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.

DeleteActionRollingFileRolloverStrategy
0 likes · 15 min read
Understanding Log4j2 RollingFile Appender: TriggeringPolicy, RolloverStrategy, and DeleteAction
Top Architect
Top Architect
Jun 9, 2021 · Operations

Configuring a Perfect JVM GC Log Printing Strategy

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.

JVMgcjava
0 likes · 12 min read
Configuring a Perfect JVM GC Log Printing Strategy
Java Interview Crash Guide
Java Interview Crash Guide
Jun 4, 2021 · Backend Development

Why Logback Beats Log4j: A Deep Dive into Configuration and Features

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.

backend-developmentjavalogback
0 likes · 22 min read
Why Logback Beats Log4j: A Deep Dive into Configuration and Features
Architecture Digest
Architecture Digest
May 29, 2021 · Backend Development

Using the BizLog SDK in Spring Boot: Configuration, Annotations, and Custom Extensions

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.

BizLogSpELSpring Boot
0 likes · 14 min read
Using the BizLog SDK in Spring Boot: Configuration, Annotations, and Custom Extensions
Amap Tech
Amap Tech
May 28, 2021 · Operations

System Observability Practices in Gaode Ride-Hailing: From Unified Logging to Fault Defense

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.

Distributed Systemsfault tolerancelogging
0 likes · 22 min read
System Observability Practices in Gaode Ride-Hailing: From Unified Logging to Fault Defense
Sohu Tech Products
Sohu Tech Products
May 19, 2021 · Mobile Development

Design and Implementation of an iOS Mobile Log System Using WCDB

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.

WCDBiOSlog system
0 likes · 16 min read
Design and Implementation of an iOS Mobile Log System Using WCDB
MaGe Linux Operations
MaGe Linux Operations
May 14, 2021 · Big Data

Build a Billion-Scale ELK Logging Platform with Filebeat, Kafka, Elasticsearch

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.

ELKElasticsearchFilebeat
0 likes · 12 min read
Build a Billion-Scale ELK Logging Platform with Filebeat, Kafka, Elasticsearch
Full-Stack DevOps & Kubernetes
Full-Stack DevOps & Kubernetes
May 7, 2021 · Cloud Native

Install Loki Locally and Query Nginx Logs with LogQL

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.

KubernetesLogQLLoki
0 likes · 11 min read
Install Loki Locally and Query Nginx Logs with LogQL
Open Source Linux
Open Source Linux
May 6, 2021 · Operations

How to Build a Scalable Container Log Collection System with S6 and Filebeat

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.

DockerFilebeatKubernetes
0 likes · 9 min read
How to Build a Scalable Container Log Collection System with S6 and Filebeat
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Apr 22, 2021 · Backend Development

Prevent Log Injection in Log4j2: Clean Input, PatternLayout, and Custom Throwable Converter

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.

Exception Handlinglog injectionlog4j2
0 likes · 8 min read
Prevent Log Injection in Log4j2: Clean Input, PatternLayout, and Custom Throwable Converter
Liangxu Linux
Liangxu Linux
Apr 19, 2021 · Cloud Native

Designing a Scalable Kubernetes Log Collection System Using S6 and Filebeat

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.

DaemonSetFilebeatKubernetes
0 likes · 8 min read
Designing a Scalable Kubernetes Log Collection System Using S6 and Filebeat
MaGe Linux Operations
MaGe Linux Operations
Apr 16, 2021 · Cloud Native

Building a Scalable Container Log System with S6, Filebeat, and Kafka

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.

FilebeatKubernetesS6
0 likes · 8 min read
Building a Scalable Container Log System with S6, Filebeat, and Kafka
Huolala Tech
Huolala Tech
Apr 16, 2021 · Cloud Native

How to Build a Scalable Kubernetes Logging Pipeline with EFK and Fluentd

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.

EFKElasticsearchFlink
0 likes · 20 min read
How to Build a Scalable Kubernetes Logging Pipeline with EFK and Fluentd
Sohu Tech Products
Sohu Tech Products
Mar 31, 2021 · Operations

Improving Cluster Stability: CI/CD, Monitoring, Logging, Documentation, and Traffic Management Solutions

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.

DevOpsKubernetesOperations
0 likes · 10 min read
Improving Cluster Stability: CI/CD, Monitoring, Logging, Documentation, and Traffic Management Solutions
Efficient Ops
Efficient Ops
Mar 28, 2021 · Cloud Native

Building a Scalable Container Log Collection System with S6 and Filebeat

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.

DockerFilebeatKubernetes
0 likes · 9 min read
Building a Scalable Container Log Collection System with S6 and Filebeat
Python Programming Learning Circle
Python Programming Learning Circle
Mar 26, 2021 · Backend Development

Building a Python API Automation Testing Framework: Design, Configuration, Logging, Database, and Email Integration

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.

API testingEmailautomation
0 likes · 20 min read
Building a Python API Automation Testing Framework: Design, Configuration, Logging, Database, and Email Integration
Ctrip Technology
Ctrip Technology
Mar 18, 2021 · Backend Development

Design and Implementation of Ctrip's Unified Accounting Platform

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.

BackendMicroservicesSystem Architecture
0 likes · 16 min read
Design and Implementation of Ctrip's Unified Accounting Platform
Taobao Frontend Technology
Taobao Frontend Technology
Mar 18, 2021 · Operations

How to Build a Robust Log Analysis System for Stable Microservices

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.

MicroservicesOperationslogging
0 likes · 13 min read
How to Build a Robust Log Analysis System for Stable Microservices
MaGe Linux Operations
MaGe Linux Operations
Mar 5, 2021 · Cloud Native

Why Loki Beats ELK for Kubernetes Logging: Architecture and Cost Benefits

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.

ELKKubernetesLoki
0 likes · 6 min read
Why Loki Beats ELK for Kubernetes Logging: Architecture and Cost Benefits
Programmer DD
Programmer DD
Mar 5, 2021 · Operations

How to Write Effective Error Logs for Faster Debugging

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.

Error Loggingbest practicesdebugging
0 likes · 19 min read
How to Write Effective Error Logs for Faster Debugging
Ctrip Technology
Ctrip Technology
Mar 4, 2021 · Cloud Native

Ctrip International Ticketing Cloud‑Native Migration: Infrastructure as Code, Logging, Monitoring, and Cost Optimization

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.

Infrastructure as CodePrometheusTerraform
0 likes · 13 min read
Ctrip International Ticketing Cloud‑Native Migration: Infrastructure as Code, Logging, Monitoring, and Cost Optimization
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 3, 2021 · Backend Development

Separating Middleware Logs with Programmatic Log4j2 Configuration in Java

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.

BackendConfigurationjava
0 likes · 8 min read
Separating Middleware Logs with Programmatic Log4j2 Configuration in Java
Java Captain
Java Captain
Feb 27, 2021 · Backend Development

SOFABoot: Enhancing Spring Boot for Large‑Scale Microservice Development

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.

Class IsolationReadiness CheckSOFABoot
0 likes · 4 min read
SOFABoot: Enhancing Spring Boot for Large‑Scale Microservice Development
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Feb 14, 2021 · Frontend Development

Building a Frontend Logging Library for SaaS B2B to Accelerate Issue Resolution

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.

B2BSaaSfrontend
0 likes · 14 min read
Building a Frontend Logging Library for SaaS B2B to Accelerate Issue Resolution
Java Backend Technology
Java Backend Technology
Feb 6, 2021 · Backend Development

Master Java Exception Handling: 10 Best Practices Every Developer Should Follow

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.

Exception Handlingbest practicesjava
0 likes · 10 min read
Master Java Exception Handling: 10 Best Practices Every Developer Should Follow
Top Architect
Top Architect
Jan 25, 2021 · Cloud Computing

Scaling Our AWS Infrastructure: Lessons from Meddy

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.

AWSDevOpsServerless
0 likes · 14 min read
Scaling Our AWS Infrastructure: Lessons from Meddy
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 11, 2021 · Backend Development

Why Tengine’s access_log Shows Fast Times While Users See Delays – Uncover the Hidden Timing Secrets

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.

Access LogBackendNetwork Latency
0 likes · 16 min read
Why Tengine’s access_log Shows Fast Times While Users See Delays – Uncover the Hidden Timing Secrets
Selected Java Interview Questions
Selected Java Interview Questions
Jan 11, 2021 · Backend Development

Best Practices for Exception Handling in Java

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.

best-practicesexception-handlinglogging
0 likes · 10 min read
Best Practices for Exception Handling in Java
macrozheng
macrozheng
Jan 6, 2021 · Backend Development

Essential Spring Boot Practices for Building Robust Microservices

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.

API documentationMicroservicesSpring Boot
0 likes · 8 min read
Essential Spring Boot Practices for Building Robust Microservices