refactor: API cleanup

Author: ganeshnj

datadog-log-ffi/src/lib.rs

@@ -19,89 +19,65 @@ pub extern "C" fn ddog_logger_set_log_level(
     logger_set_log_level(log_level).err().map(Box::new)
 }
 
-/// Configures the global logger.
-///
-/// # Arguments
-/// * `config` - Configuration for the logger including level and output destination
+/// Disables logging by configuring a no-op logger.
 ///
 /// # Errors
 /// Returns an error if the logger cannot be configured.
 #[no_mangle]
-pub extern "C" fn ddog_logger_configure(config: LoggerConfig) -> Option<Box<Error>> {
-    logger_configure(logger::LoggerConfig::from(config))
-        .err()
-        .map(Box::new)
+pub extern "C" fn ddog_logger_disable() -> Option<Box<Error>> {
+    let config = logger::LoggerConfig {
+        level: logger::LogEventLevel::Error, // Set to the highest level to minimize logging
+        writer: logger::WriterConfig::Noop,
+    };
+    logger_configure(config).err().map(Box::new)
 }
 
-/// Configuration for the logger.
+/// Configuration for stdout output.
 #[repr(C)]
-pub struct LoggerConfig<'a> {
+pub struct StdoutConfig {
     /// Minimum level for events to be logged
     pub level: logger::LogEventLevel,
-    /// Output configuration
-    pub writer: WriterConfig<'a>,
 }
 
-/// Configuration for log output destination.
-#[repr(C)]
-pub struct WriterConfig<'a> {
-    /// Type of output destination
-    pub kind: WriterKind,
-    /// File configuration, required when `kind` is [`WriterKind::File`]
-    pub file: Option<&'a FileConfig<'a>>,
+/// Configures the logger to write to stdout with the specified configuration.
+///
+/// # Arguments
+/// * `config` - Configuration for stdout logging including log level
+///
+/// # Errors
+/// Returns an error if the logger cannot be configured.
+#[no_mangle]
+pub extern "C" fn ddog_logger_configure_stdout(config: StdoutConfig) -> Option<Box<Error>> {
+    let logger_config = logger::LoggerConfig {
+        level: config.level,
+        writer: logger::WriterConfig::Stdout,
+    };
+    logger_configure(logger_config).err().map(Box::new)
 }
 
 /// Configuration for file output.
 #[repr(C)]
 pub struct FileConfig<'a> {
     /// Path to the log file
     pub path: CharSlice<'a>,
+    /// Minimum level for events to be logged
+    pub level: logger::LogEventLevel,
 }
 
-/// Type of log output destination.
-#[repr(C)]
-pub enum WriterKind {
-    /// Discard all output
-    Noop,
-    /// Write to standard output
-    Stdout,
-    /// Write to file
-    File,
-}
-
-impl From<LoggerConfig<'_>> for logger::LoggerConfig {
-    fn from(config: LoggerConfig) -> Self {
-        logger::LoggerConfig {
-            level: config.level,
-            writer: logger::WriterConfig::from(config.writer),
-        }
-    }
-}
-
-impl From<WriterConfig<'_>> for logger::WriterConfig {
-    fn from(config: WriterConfig) -> Self {
-        match config.kind {
-            WriterKind::Noop => logger::WriterConfig::Noop,
-            WriterKind::Stdout => logger::WriterConfig::Stdout,
-            WriterKind::File => {
-                match config.file {
-                    Some(file_config) => {
-                        logger::WriterConfig::File(logger::FileConfig::from(FileConfig {
-                            path: file_config.path,
-                        }))
-                    }
-                    None => logger::WriterConfig::Noop, /* If no file config is provided,
-                                                         * fallback to Noop */
-                }
-            }
-        }
-    }
-}
-
-impl From<FileConfig<'_>> for logger::FileConfig {
-    fn from(file_config: FileConfig) -> Self {
-        logger::FileConfig {
-            path: file_config.path.to_string(),
-        }
-    }
+/// Configures the logger to write to a file with the specified configuration.
+///
+/// # Arguments
+/// * `config` - Configuration for file logging including path and log level
+///
+/// # Errors
+/// Returns an error if the logger cannot be configured.
+#[no_mangle]
+pub extern "C" fn ddog_logger_configure_file(config: FileConfig) -> Option<Box<Error>> {
+    let logger_config = logger::LoggerConfig {
+        level: config.level,
+        writer: logger::WriterConfig::File(logger::FileConfig {
+            path: config.path.to_string(),
+        }),
+    };
+    logger_configure(logger_config).err().map(Box::new)
 }

docs/RFCs/0010-logging-in-libdatadog.md

@@ -29,12 +29,13 @@ This RFC proposes two common logging sinks for libdatadog while keeping the APIs
 
 The logging system provides a simple and flexible public interface for configuring logging behavior in libdatadog. The interface consists of:
 
-* Two primary configuration functions:
-  * `ddog_logger_configure` - For setting up the logger with desired output destination and level
+* Four primary configuration functions:
+  * `ddog_logger_disable` - For disabling logging completely
+  * `ddog_logger_configure_stdout` - For setting up console logging
+  * `ddog_logger_configure_file` - For setting up file-based logging
   * `ddog_logger_set_log_level` - For updating the minimum log level at runtime
   * These methods must be implemented in a thread-safe manner
-* Three supported output destinations:
-  * Noop - For disabling logging (since libdatadog allows disabling logging)
+* Supported output destinations:
   * Stdout - For console output
   * File - For writing to a specified file
 * Configuration structures that provide:
@@ -63,51 +64,52 @@ pub extern "C" fn ddog_logger_set_log_level(
     log_level: LogEventLevel,
 ) -> Option<Box<Error>>;
 
-/// Configures the global logger.
-///
-/// # Arguments
-/// * `config` - Configuration for the logger including level and output destination
+/// Disables logging by configuring a no-op logger.
 ///
 /// # Errors
 /// Returns an error if the logger cannot be configured.
 #[no_mangle]
-pub extern "C" fn ddog_logger_configure(config: LoggerConfig) -> Option<Box<Error>>;
+pub extern "C" fn ddog_logger_disable() -> Option<Box<Error>>;
 
-/// Configuration for the logger.
+/// Configuration for stdout output.
 #[repr(C)]
-pub struct LoggerConfig<'a> {
+pub struct StdoutConfig {
     /// Minimum level for events to be logged
     pub level: LogEventLevel,
-    /// Output configuration
-    pub writer: WriterConfig<'a>,
-}
-
-/// Configuration for log output destination.
-#[repr(C)]
-pub struct WriterConfig<'a> {
-    /// Type of output destination
-    pub kind: WriterKind,
-    /// File configuration, required when `kind` is WriterKind::File
-    pub file: Option<&'a FileConfig<'a>>,
 }
 
-/// Type of log output destination.
-#[repr(C)]
-pub enum WriterKind {
-    /// Discard all output
-    Noop,
-    /// Write to standard output
-    Stdout,
-    /// Write to file
-    File,
-}
+/// Configures the logger to write to stdout with the specified configuration.
+///
+/// # Arguments
+/// * `config` - Configuration for stdout logging including log level
+///
+/// # Errors
+/// Returns an error if the logger cannot be configured.
+#[no_mangle]
+pub extern "C" fn ddog_logger_configure_stdout(
+    config: StdoutConfig,
+) -> Option<Box<Error>>;
 
 /// Configuration for file output.
 #[repr(C)]
 pub struct FileConfig<'a> {
     /// Path to the log file
     pub path: CharSlice<'a>,
+    /// Minimum level for events to be logged
+    pub level: LogEventLevel,
 }
+
+/// Configures the logger to write to a file with the specified configuration.
+///
+/// # Arguments
+/// * `config` - Configuration for file logging including path and log level
+///
+/// # Errors
+/// Returns an error if the logger cannot be configured.
+#[no_mangle]
+pub extern "C" fn ddog_logger_configure_file(
+    config: FileConfig,
+) -> Option<Box<Error>>;
 ```
 
 ### Example Usage

examples/ffi/trace_exporter.c

@@ -25,36 +25,34 @@ void handle_log_error(ddog_Error *err) {
 }
 
 int log_init(const char* log_path) {
-    // Create logger config with debug level
-    struct ddog_LoggerConfig config = {
-        .level = DDOG_LOG_EVENT_LEVEL_DEBUG
-    };
-
-    // Setup writer configuration based on log_path
-    struct ddog_FileConfig file_config;
-    if (log_path != NULL) {
-        // Configure file-based logging
-        file_config.path = (ddog_CharSlice){
-            .ptr = log_path,
-            .len = strlen(log_path)
+    if (log_path == NULL) {
+        // Configure stdout logging with debug level
+        struct ddog_StdoutConfig stdout_config = {
+            .level = DDOG_LOG_EVENT_LEVEL_DEBUG
         };
-        config.writer.kind = DDOG_WRITER_KIND_FILE;
-        config.writer.file = &file_config;
+        struct ddog_Error *err = ddog_logger_configure_stdout(stdout_config);
+        if (err) {
+            handle_log_error(err);
+            return 1;
+        }
     } else {
-        // Configure stdout logging
-        config.writer.kind = DDOG_WRITER_KIND_STDOUT;
-        config.writer.file = NULL;
-    }
-
-    // Initialize the logger
-    struct ddog_Error *err = ddog_logger_configure(config);
-    if (err) {
-        handle_log_error(err);
-        return 1;
+        // Configure file logging
+        struct ddog_FileConfig file_config = {
+            .path = (ddog_CharSlice){
+                .ptr = log_path,
+                .len = strlen(log_path)
+            },
+            .level = DDOG_LOG_EVENT_LEVEL_DEBUG
+        };
+        struct ddog_Error *err = ddog_logger_configure_file(file_config);
+        if (err) {
+            handle_log_error(err);
+            return 1;
+        }
     }
 
     // Set the log level, just for checking the API
-    err = ddog_logger_set_log_level(DDOG_LOG_EVENT_LEVEL_TRACE);
+    struct ddog_Error *err = ddog_logger_set_log_level(DDOG_LOG_EVENT_LEVEL_TRACE);
     if (err) {
         handle_log_error(err);
         return 1;