Optimize debug log in cpp parser

Author: melodyoncode

cpp/libclang/BUILD

@@ -10,8 +10,22 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
+load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
 load("@rules_rust//rust:defs.bzl", "rust_binary")
 
+string_flag(
+    name = "log_level",
+    build_setting_default = "error",
+    values = [
+        "error",
+        "warn",
+        "info",
+        "debug",
+        "trace",
+    ],
+    visibility = ["//visibility:public"],
+)
+
 rust_binary(
     name = "clang_rs_parser",
     srcs = ["src/main.rs"],
@@ -23,9 +37,12 @@ rust_binary(
     },
     visibility = ["//visibility:public"],
     deps = [
+        "//cpp/libclang/src/utils",
         "//cpp/libclang/src/visitor:visit_tu",
         "@crates//:clang",
         "@crates//:clap",
+        "@crates//:env_logger",
+        "@crates//:log",
         "@crates//:serde_json",
     ],
 )

cpp/libclang/README.md

@@ -38,6 +38,16 @@ Expected result:
 - Bazel creates parser output artifact:
   - `bazel-bin/cpp/libclang/cpp_parser_include_3rdparty_result.json`
 
+## Configure debug logging
+
+To enable debug output for parser actions, set the Bazel build setting:
+
+```bash
+bazel build //cpp/libclang/integration_test/cases/include_3rdparty:parser --//cpp/libclang:log_level=debug
+```
+
+Accepted values are: `error`, `warn`, `info`, `debug`, `trace`.
+
 ## Quick check (optional)
 
 ```bash

cpp/libclang/cpp_parser.bzl

@@ -10,6 +10,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
 load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain", "use_cc_toolchain")
 load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
 
@@ -237,6 +238,7 @@ def _cpp_parser_impl(ctx):
         arguments = args,
         env = {
             "LIBCLANG_PATH": libclang.dirname,
+            "LIBCLANG_LOG": ctx.attr._log_level[BuildSettingInfo].value,
         },
         mnemonic = "CppAnalyze",
         # this is required to parse some system headers
@@ -279,6 +281,10 @@ cpp_parser = rule(
             doc = "LLVM toolchain filegroup containing the arch-specific __config_site file " +
                   "(include/<triple>/c++/v1/__config_site) used to locate the ABI include path.",
         ),
+        "_log_level": attr.label(
+            default = Label("//cpp/libclang:log_level"),
+            doc = "Build setting that controls clang_rs_parser log level.",
+        ),
     },
     toolchains = use_cc_toolchain(),
     fragments = ["cpp"],

cpp/libclang/src/main.rs

@@ -10,13 +10,14 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 ////////////////////////////////////////////////////////////////////////////////////
-use clang::{Entity, EntityKind, EntityVisitResult};
 use clap::Parser as ClapParser;
+use env_logger::Builder;
+use log::{debug, error, LevelFilter};
 use std::collections::BTreeMap;
 use std::fs;
-use std::fs::OpenOptions;
-use std::io::{BufWriter, Write};
 use std::path::PathBuf;
+
+use utils::{render_entity_tree, write_entity_tree};
 use visit_tu::context;
 use visit_tu::visitor;
 use visit_tu::{FunctionDef, VisitContext, Visitor};
@@ -41,10 +42,6 @@ struct Args {
     /// Output JSON format for debugging (internal use only)
     #[arg(long, hide = true)]
     json: bool,
-
-    /// Print verbose output
-    #[arg(short, long)]
-    verbose: bool,
 }
 
 fn parse_file(
@@ -55,11 +52,11 @@ fn parse_file(
     all_classes: &mut BTreeMap<String, context::TypeMapValue>,
     all_functions: &mut Vec<FunctionDef>,
 ) {
-    println!("Parsing TU: {:?}", file);
+    debug!("Parsing TU: {:?}", file);
 
     if let Some(path_str) = file.to_str() {
         if visitor::is_external_dependency_path(path_str) {
-            println!("  Skipping external dependency file: {:?}", file);
+            debug!("Skipping external dependency file: {:?}", file);
             return;
         }
     };
@@ -68,62 +65,88 @@ fn parse_file(
 
     match parse_result {
         Ok(parsed) => {
-            println!("  Parsed successfully, parsed is {:?}", parsed);
-
             let diagnostics = parsed.get_diagnostics();
             if !diagnostics.is_empty() {
-                println!("  Diagnostics: {}", diagnostics.len());
+                debug!("Diagnostics: {}", diagnostics.len());
+                for diagnostic in &diagnostics {
+                    debug!("Diagnostic: {:?}", diagnostic);
+                }
             }
 
             let entity = parsed.get_entity();
-            print_entity(&entity, 0, PrintMode::File(ast_file_output_path));
-            print_entity(&entity, 0, PrintMode::Stdout);
+            debug!("Parsed {:?} successfully", parsed);
+            if log::log_enabled!(log::Level::Trace) {
+                let entity_tree = render_entity_tree(&entity, 0);
+                write_entity_tree(ast_file_output_path, &entity_tree);
+            }
 
             let mut ctx = VisitContext::default();
             let mut visitor = Visitor::new(&mut ctx);
             visitor.visit(entity);
-            println!(
-                "  Visited TU, extracted {} classes, {} functions",
+            debug!(
+                "Visited TU, extracted {} classes, {} functions",
                 ctx.types.len(),
                 ctx.functions.len()
             );
             for (class_name, logic_class) in &ctx.types {
-                println!("  - class: {}", class_name);
-                println!("{:#?}", logic_class);
+                debug!("Class {}:\n{:#?}", class_name, logic_class);
                 all_classes.insert(class_name.clone(), logic_class.clone());
             }
             all_functions.extend(ctx.functions);
         }
         Err(e) => {
-            eprintln!("  Failed to parse {:?}: {:?}", file, e);
+            error!("Failed to parse {:?}: {:?}", file, e);
         }
     }
 }
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("=== libclang Information ===\n");
-    println!("Command line: {:?}", std::env::args().collect::<Vec<_>>());
+fn parse_log_level_from_env() -> LevelFilter {
+    std::env::var("LIBCLANG_LOG")
+        .ok()
+        .and_then(|value| value.parse::<LevelFilter>().ok())
+        .unwrap_or(LevelFilter::Error)
+}
+
+fn init_logging() {
+    Builder::new()
+        .filter_level(parse_log_level_from_env())
+        .init();
+}
+
+fn init_libclang() -> clang::Clang {
+    debug!("=== libclang Information ===");
+    debug!("Command line: {:?}", std::env::args().collect::<Vec<_>>());
 
     if let Ok(path) = std::env::var("LIBCLANG_PATH") {
-        println!("LIBCLANG_PATH: {}", path);
+        debug!("LIBCLANG_PATH: {}", path);
     }
 
-    // Load clang - keep it alive for the entire scope
     let clang = match clang::Clang::new() {
         Ok(c) => {
-            println!("✓ Successfully loaded libclang\n");
+            debug!("Successfully loaded libclang");
             c
         }
         Err(e) => {
-            eprintln!("Failed to load libclang: {}", e);
+            error!("Failed to load libclang: {}", e);
             std::process::exit(1);
         }
     };
 
-    // All operations use the clang-rs wrapper API
-    let index = clang::Index::new(&clang, false, true);
-    println!("✓ Created clang index");
-    println!("libclang version: {}", clang::get_version());
+    debug!("libclang version: {}", clang::get_version());
+    debug!("Using Bazel's LLVM toolchain with clang-rs wrapper");
+    clang
+}
+
+fn init_clang_index(clang: &clang::Clang) -> clang::Index {
+    let index = clang::Index::new(clang, false, true);
+    debug!("Created clang index");
+    index
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    init_logging();
+    let clang = init_libclang();
+    let index = init_clang_index(&clang);
 
     let command_line_args = Args::parse();
     let mut all_classes = BTreeMap::new();
@@ -155,59 +178,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     );
     let output_json = serde_json::to_string_pretty(&output)?;
     fs::write(&command_line_args.output, output_json)?;
-    println!("Wrote AST JSON to {:?}", command_line_args.output);
-    println!("\n Using Bazel's LLVM toolchain with clang-rs wrapper!");
+    debug!("Wrote AST JSON to {:?}", command_line_args.output);
 
     Ok(())
 }
-
-enum PrintMode<'a> {
-    Stdout,
-    File(&'a PathBuf),
-}
-
-fn print_entity(entity: &Entity, level: usize, print_mode: PrintMode) {
-    match print_mode {
-        PrintMode::Stdout => {
-            let mut stdout = std::io::stdout().lock();
-            print_entity_to(entity, level, &mut stdout)
-        }
-        PrintMode::File(path) => {
-            let file = OpenOptions::new()
-                .create(true)
-                .append(true)
-                .open(path)
-                .unwrap_or_else(|e| {
-                    panic!("Failed to open file {:?} for writing: {}", path, e);
-                });
-            let mut file_out = BufWriter::new(file);
-            print_entity_to(entity, level, &mut file_out)
-        }
-    }
-}
-
-fn print_entity_to(entity: &Entity, level: usize, out: &mut dyn Write) {
-    let indent = "  ".repeat(level);
-    let kind = entity.get_kind();
-    let spelling = match kind {
-        EntityKind::AccessSpecifier => entity
-            .get_accessibility()
-            .map(|a| format!("{:?}", a).to_lowercase())
-            .unwrap_or_default(),
-        _ => entity.get_name().unwrap_or_default(),
-    };
-    let output = format!("{}{:?} | {}\n", indent, kind, spelling);
-
-    // we soft fail since this is just a diagnostic print and should not crush the main programm
-    out.write_all(output.as_bytes()).unwrap_or_else(|e| {
-        eprintln!("Failed to write entity info: {}", e);
-    });
-    out.flush().unwrap_or_else(|e| {
-        eprintln!("Failed to flush output: {}", e);
-    });
-
-    entity.visit_children(|child, _parent| {
-        print_entity_to(&child, level + 1, out);
-        EntityVisitResult::Continue
-    });
-}

cpp/libclang/src/utils/BUILD

@@ -0,0 +1,27 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "utils",
+    srcs = [
+        "lib.rs",
+        "render.rs",
+        "write.rs",
+    ],
+    visibility = ["//cpp/libclang:__pkg__"],
+    deps = [
+        "@crates//:clang",
+        "@crates//:log",
+    ],
+)

cpp/libclang/src/utils/lib.rs

@@ -0,0 +1,17 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2026 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache License Version 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// SPDX-License-Identifier: Apache-2.0
+////////////////////////////////////////////////////////////////////////////////////
+mod render;
+mod write;
+
+pub use render::render_entity_tree;
+pub use write::write_entity_tree;

cpp/libclang/src/utils/render.rs

@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2026 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache License Version 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// SPDX-License-Identifier: Apache-2.0
+////////////////////////////////////////////////////////////////////////////////////
+use clang::{Entity, EntityKind, EntityVisitResult};
+
+pub fn render_entity_tree(entity: &Entity, level: usize) -> String {
+    let mut output = String::new();
+    append_entity_tree(entity, level, &mut output);
+    output
+}
+
+fn append_entity_tree(entity: &Entity, level: usize, output: &mut String) {
+    output.push_str(&format_entity_line(entity, level));
+    output.push('\n');
+
+    entity.visit_children(|child, _parent| {
+        append_entity_tree(&child, level + 1, output);
+        EntityVisitResult::Continue
+    });
+}
+
+fn format_entity_line(entity: &Entity, level: usize) -> String {
+    let indent = "  ".repeat(level);
+    let kind = entity.get_kind();
+    let spelling = match kind {
+        EntityKind::AccessSpecifier => entity
+            .get_accessibility()
+            .map(|a| format!("{:?}", a).to_lowercase())
+            .unwrap_or_default(),
+        _ => entity.get_name().unwrap_or_default(),
+    };
+
+    format!("{}{:?} | {}", indent, kind, spelling)
+}