debugging and logging

Configurable systems frequently suffer from erroneous configurations and latent defects due to the complexity of their configuration spaces; existing diagnostic approaches predominantly focus on post-failure analysis and overlook the diagnostic potential embedded in software logs for configuration-related issues. This paper proposes a configuration-aware log enhancement method: it employs static taint analysis to identify propagation paths of critical configuration variables and leverages large language models (LLMs) to generate context-sensitive, semantically rich diagnostic log statements, while optimizing variable capture and code-context modeling. To our knowledge, this is the first automated configuration-log generation framework integrating static data-flow analysis with LLM-based semantic understanding. Evaluated across eight widely used systems, the method achieves 100% localization accuracy for 30 categories of silent misconfigurations, enables direct repair for 80% of such issues, improves diagnostic efficiency by 1.25×, and increases diagnostic accuracy by 251.4%.

Low-quality log statements—such as ambiguous or misleading ones—obscure actual program behavior and impede software maintenance. Prior work primarily focuses on detecting single log defects and relies on manual fixes. This paper proposes LogFixer, the first automated two-stage framework targeting four real-world log defects: detection and repair. In the offline stage, a lightweight similarity classifier is trained on synthetically defective logs; in the online stage, problematic logs are identified via joint modeling of static textual features and dynamic variable contexts, and semantically appropriate repairs are recommended using large language models (LLMs). LogFixer innovatively integrates a lightweight classifier with LLMs in a synergistic paradigm, ensuring robust detection while enhancing repair validity. Evaluation shows an F1-score of 0.625; adoption rates of static and dynamic repair suggestions improve by 48.12% and 24.90%, respectively; repair suggestion adoption reaches 61.49% on unseen projects; and 40 fixes submitted to GitHub have yielded 25 merged confirmations.

Cloud-native systems face fragmented observability and challenging root-cause analysis due to their distributed, highly dynamic architectures. To address this, this paper proposes a reusable, observability-oriented design pattern system comprising three core categories: distributed tracing, application-level metric modeling, and infrastructure-level metric collection. Unlike ad-hoc toolchain integrations, our work is the first to systematically abstract industrial practices into structured, composable design patterns that holistically guide end-to-end monitoring architecture. Implemented and validated using mainstream frameworks—including OpenTelemetry and Prometheus—the approach significantly improves latency attribution accuracy, resource utilization assessment efficiency, and anomaly detection timeliness. Empirical evaluation across multiple microservice deployments demonstrates a 42% reduction in mean time to identify failures.

Existing research on automated log generation is largely confined to a single programming language, limiting the evaluation of methods' generalization across multiple languages and real-world code evolution. This work proposes MultiLogBench—the first comprehensive, maintenance-oriented benchmark for automated logging that spans six programming languages, 63,965 code snapshots, and 744 historical cases of log introduction. Under a unified evaluation protocol, we assess seven large language models on tasks including log placement, framework matching, and severity prediction. Our experiments reveal significant performance variations across languages and code structures—particularly in loops and nested calls—with framework anchor matching showing the highest language sensitivity. Only top-tier models exhibit consistent rankings, underscoring the necessity of multilingual evaluation for advancing automated logging research.

Traditional interactive debuggers struggle to support distributed systems due to fragmented call stacks across process boundaries, difficulty in maintaining debugging state, and the risk of timeout cascades caused by global halting. This work proposes a novel approach enabling cross-process, source-level interactive debugging by embedding causal metadata into RPCs to reconstruct unified call stacks via distributed backtracing, designing an intent-preserving control plane that automatically coordinates dynamic breakpoints, and virtualizing logical clocks to eliminate temporal discontinuities. The system integrates lightweightly with frameworks such as gRPC, achieving a median cross-RPC backtrace latency of 30 ms, time skew under 5 ms, and throughput overhead of only 1–5% across 122 processes. User studies demonstrate a 100% success rate in fault localization with a median diagnosis time of approximately 8 minutes.

This study addresses the lack of systematic understanding of developers’ logging practices by analyzing over 210,000 logging-related questions from Stack Overflow. It presents the first thematic categorization of logging topics that integrates large language models with manual validation and introduces multidimensional community metrics—such as the proportion of questions without accepted answers and median time to resolution—to quantitatively assess topic difficulty and popularity. The analysis identifies eleven distinct logging themes, revealing that logging in containerized environments is the most challenging, with 64.9% of related questions lacking an accepted answer. These findings offer empirical insights and actionable guidance for practitioners, tool designers, and educators seeking to improve logging practices and support in modern software development contexts.

This work proposes an automated log aggregation and analysis framework based on large language models to address the growing challenge of log analysis in increasingly complex systems, where engineers traditionally rely on domain expertise to manually craft intricate LogQL queries. The framework enables end-to-end generation of LogQL queries from natural language instructions by integrating a hierarchical log knowledge base, natural language understanding, knowledge retrieval, and tool invocation mechanisms. Evaluated on four real-world log datasets, the approach achieves an average accuracy of 76.8%, significantly outperforming existing baselines and demonstrating its effectiveness and practicality for log analysis tasks.

This work proposes the first unified formal framework that integrates runtime verification and model-based diagnosis, overcoming the limitations of traditional approaches that rely on disjoint toolchains and struggle to jointly support online fault detection and localization. Built upon the LOLA stream specification language, the method encodes system behavior, component health states, and observational data into a common stream-based representation. This formulation accommodates both time-invariant and transient faults and handles nondeterministic observations. By leveraging online stream processing and explicit fault semantics, the approach enables efficient, continuous end-to-end fault localization without requiring additional tools, thereby significantly enhancing the integration and practicality of runtime monitoring for complex systems.

This work addresses the pervasive issue of redundant and isolated messages in system logs, which hinder downstream tasks such as model reasoning and anomaly detection. To tackle this challenge, the authors propose LogPurifier—the first task-agnostic log cleansing framework—that systematically purifies logs by extracting log templates and modeling their dependencies to accurately identify and remove messages irrelevant to system functional behavior. By doing so, LogPurifier enables effective log sanitization applicable across diverse analytical scenarios. Experimental results demonstrate that LogPurifier substantially improves both accuracy and efficiency in various downstream tasks, thereby validating its effectiveness and generalizability.

Existing debugging tools excel at verifying hypotheses but struggle to support hypothesis generation, as programmers must manually reconstruct the program’s state evolution. This work proposes a novel debugging paradigm centered on complete execution traces, leveraging program tracing techniques to record and temporally visualize the actual code paths executed, rather than relying on the static structure of the source code. By presenting runtime behavior in a chronological and contextualized manner, this approach significantly enhances the comprehensibility of program execution, thereby facilitating more efficient hypothesis generation during debugging. We implement a prototype system and conduct preliminary experiments that demonstrate its effectiveness in improving program understanding efficiency, while also uncovering key challenges and promising directions for future research.