[exporter/debug] add ability to set output_paths

.chloggen/debug-exporter-output-paths.yaml

@@ -0,0 +1,29 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' 
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: exporter/debug
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add `output_paths` configuration option to control output destination when `use_internal_logger` is false
+
+# One or more tracking issues or pull requests related to the change
+issues: [10472]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext: |
+  When `use_internal_logger` is set to `false`, the debug exporter now supports configuring the output destination via the `output_paths` option.
+  This allows users to send debug exporter output to `stdout`, `stderr`, or a file path.
+  The default value is `["stdout"]` to maintain backward compatibility.
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: []
+

exporter/debugexporter/README.md

@@ -37,6 +37,7 @@ The following settings are optional:
   Refer to [Zap docs](https://godoc.org/go.uber.org/zap/zapcore#NewSampler) for more details
   on how sampling parameters impact number of messages.
 - `use_internal_logger` (default = `true`): uses the collector's internal logger for output. See [below](#using-the-collectors-internal-logger) for description.
+- `output_paths` (default = `["stdout"]`): a list of file paths to write output to. This option can only be used when `use_internal_logger` is `false`. Special strings "stdout" and "stderr" are interpreted as [standard output](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)) and [standard error](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)) respectively. All other values are treated as file paths. Setting `output_paths` when `use_internal_logger` is `true` results in a configuration error.
 - `sending_queue` (disabled by default): see [Sending Queue](../exporterhelper/README.md#sending-queue) for the full set of available options.
 
 Example configuration:
@@ -49,6 +50,16 @@ exporters:
     sampling_thereafter: 200
 ```
 
+Example configuration with custom output path:
+
+```yaml
+exporters:
+  debug:
+    use_internal_logger: false
+    output_paths:
+      - stderr
+```
+
 ## Verbosity levels
 
 The following subsections describe the output from the exporter depending on the configured verbosity level - `basic`, `normal` and `detailed`.
@@ -137,7 +148,8 @@ This comes with the following consequences:
 
 When `use_internal_logger` is set to `false`, the exporter does not use the collector's internal logger.
 Changing the values in `service::telemetry::logs` has no effect on the exporter's output.
-The exporter's output is sent to `stdout`.
+The exporter's output is sent to the paths specified in `output_paths` (default: `["stdout"]`).
+You can configure `output_paths` to send output to `stderr`, a file, or multiple destinations.
 
 [internal_telemetry]: https://opentelemetry.io/docs/collector/internal-telemetry/
 [internal_logs_config]: https://opentelemetry.io/docs/collector/internal-telemetry/#configure-internal-logs

exporter/debugexporter/config.go

@@ -4,6 +4,7 @@
 package debugexporter // import "go.opentelemetry.io/collector/exporter/debugexporter"
 
 import (
+	"errors"
 	"fmt"
 
 	"go.opentelemetry.io/collector/component"
@@ -34,6 +35,13 @@ type Config struct {
 	// UseInternalLogger defines whether the exporter sends the output to the collector's internal logger.
 	UseInternalLogger bool `mapstructure:"use_internal_logger"`
 
+	// OutputPaths is a list of file paths to write logging output to.
+	// This option can only be used when use_internal_logger is false.
+	// Special strings "stdout" and "stderr" are interpreted as os.Stdout and os.Stderr respectively.
+	// All other values are treated as file paths.
+	// If not set, defaults to ["stdout"].
+	OutputPaths []string `mapstructure:"output_paths"`
+
 	QueueConfig configoptional.Optional[exporterhelper.QueueBatchConfig] `mapstructure:"sending_queue"`
 
 	// prevent unkeyed literal initialization
@@ -48,5 +56,17 @@ func (cfg *Config) Validate() error {
 		return fmt.Errorf("verbosity level %q is not supported", cfg.Verbosity)
 	}
 
+	// output_paths is only used when use_internal_logger is false
+	// If set when use_internal_logger is true, it would be ignored, which is confusing
+	if cfg.UseInternalLogger && cfg.OutputPaths != nil {
+		return errors.New("output_paths is not supported when use_internal_logger is true")
+	}
+
+	// If use_internal_logger is false and output_paths is explicitly set to empty, error
+	// (nil output_paths will default to ["stdout"] in createCustomLogger)
+	if !cfg.UseInternalLogger && cfg.OutputPaths != nil && len(cfg.OutputPaths) == 0 {
+		return errors.New("output_paths must not be empty when use_internal_logger is false")
+	}
+
 	return nil
 }

exporter/debugexporter/config_test.go

@@ -25,24 +25,41 @@ func TestUnmarshalDefaultConfig(t *testing.T) {
 }
 
 func TestUnmarshalConfig(t *testing.T) {
-	queueCfg := exporterhelper.NewDefaultQueueConfig()
 	tests := []struct {
-		filename    string
-		cfg         *Config
-		expectedErr string
+		filename             string
+		cfg                  *Config
+		expectedUnmarshalErr string
+		expectedValidateErr  string
 	}{
 		{
 			filename: "config_verbosity.yaml",
 			cfg: &Config{
 				Verbosity:          configtelemetry.LevelDetailed,
 				SamplingInitial:    10,
 				SamplingThereafter: 50,
-				QueueConfig:        configoptional.Default(queueCfg),
+				UseInternalLogger:  false,
+				OutputPaths:        []string{"stdout"},
+				QueueConfig:        configoptional.Default(exporterhelper.NewDefaultQueueConfig()),
+			},
+		},
+		{
+			filename: "config_output_paths.yaml",
+			cfg: &Config{
+				Verbosity:          configtelemetry.LevelBasic,
+				SamplingInitial:    2,
+				SamplingThereafter: 1,
+				UseInternalLogger:  false,
+				OutputPaths:        []string{"stderr"},
+				QueueConfig:        configoptional.Default(exporterhelper.NewDefaultQueueConfig()),
 			},
 		},
 		{
-			filename:    "config_verbosity_typo.yaml",
-			expectedErr: "has invalid keys: verBosity",
+			filename:            "config_output_paths_empty.yaml",
+			expectedValidateErr: "output_paths must not be empty when use_internal_logger is false",
+		},
+		{
+			filename:             "config_verbosity_typo.yaml",
+			expectedUnmarshalErr: "has invalid keys: verBosity",
 		},
 	}
 
@@ -53,12 +70,20 @@ func TestUnmarshalConfig(t *testing.T) {
 			factory := NewFactory()
 			cfg := factory.CreateDefaultConfig()
 			err = cm.Unmarshal(&cfg)
-			if tt.expectedErr != "" {
-				assert.ErrorContains(t, err, tt.expectedErr)
-			} else {
-				require.NoError(t, err)
-				assert.Equal(t, tt.cfg, cfg)
+			if tt.expectedUnmarshalErr != "" {
+				require.ErrorContains(t, err, tt.expectedUnmarshalErr)
+				return
+			}
+			require.NoError(t, err)
+
+			cfgCasted := cfg.(*Config)
+			err = cfgCasted.Validate()
+			if tt.expectedValidateErr != "" {
+				require.ErrorContains(t, err, tt.expectedValidateErr)
+				return
 			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.cfg, cfg)
 		})
 	}
 }
@@ -122,7 +147,45 @@ func TestValidate(t *testing.T) {
 		{
 			name: "verbosity detailed",
 			cfg: &Config{
-				Verbosity: configtelemetry.LevelDetailed,
+				Verbosity:         configtelemetry.LevelDetailed,
+				UseInternalLogger: true, // Default behavior
+			},
+		},
+		{
+			name: "empty output_paths when use_internal_logger is false",
+			cfg: &Config{
+				UseInternalLogger: false,
+				OutputPaths:       []string{},
+			},
+			expectedErr: "output_paths must not be empty when use_internal_logger is false",
+		},
+		{
+			name: "valid output_paths when use_internal_logger is false",
+			cfg: &Config{
+				UseInternalLogger: false,
+				OutputPaths:       []string{"stdout"},
+			},
+		},
+		{
+			name: "nil output_paths when use_internal_logger is false (defaults to stdout)",
+			cfg: &Config{
+				UseInternalLogger: false,
+				OutputPaths:       nil,
+			},
+		},
+		{
+			name: "output_paths set when use_internal_logger is true (not allowed)",
+			cfg: &Config{
+				UseInternalLogger: true,
+				OutputPaths:       []string{"stderr"},
+			},
+			expectedErr: "output_paths is not supported when use_internal_logger is true",
+		},
+		{
+			name: "nil output_paths when use_internal_logger is true (allowed)",
+			cfg: &Config{
+				UseInternalLogger: true,
+				OutputPaths:       nil,
 			},
 		},
 	}
@@ -131,7 +194,7 @@ func TestValidate(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			err := tt.cfg.Validate()
 			if tt.expectedErr != "" {
-				assert.EqualError(t, err, tt.expectedErr)
+				assert.ErrorContains(t, err, tt.expectedErr)
 			} else {
 				assert.NoError(t, err)
 			}

exporter/debugexporter/exporter_test.go

@@ -128,6 +128,18 @@ func createTestCases() []testCase {
 				return cfg
 			}(),
 		},
+		{
+			name: "custom output paths",
+			config: func() *Config {
+				cfg := createDefaultConfig().(*Config)
+				queueCfg := exporterhelper.NewDefaultQueueConfig()
+				queueCfg.QueueSize = 10
+				cfg.QueueConfig = configoptional.Some(queueCfg)
+				cfg.UseInternalLogger = false
+				cfg.OutputPaths = []string{"stderr"}
+				return cfg
+			}(),
+		},
 	}
 }
 

exporter/debugexporter/factory.go

@@ -126,6 +126,10 @@ func createCustomLogger(exporterConfig *Config) *zap.Logger {
 	encoderConfig.LevelKey = ""
 	// Do not prefix the output with current timestamp.
 	encoderConfig.TimeKey = ""
+	outputPaths := exporterConfig.OutputPaths
+	if outputPaths == nil {
+		outputPaths = []string{"stdout"}
+	}
 	zapConfig := zap.Config{
 		Level:         zap.NewAtomicLevelAt(zap.InfoLevel),
 		DisableCaller: true,
@@ -135,8 +139,7 @@ func createCustomLogger(exporterConfig *Config) *zap.Logger {
 		},
 		Encoding:      "console",
 		EncoderConfig: encoderConfig,
-		// Send exporter's output to stdout. This should be made configurable.
-		OutputPaths: []string{"stdout"},
+		OutputPaths:   outputPaths,
 	}
 	return zap.Must(zapConfig.Build())
 }