[otelcol] Fix missing defaults in unredacted print-config (#14752)

**Description**

Fixes an issue where `otelcol print-config --mode=unredacted` omits
default values, causing its output structure to differ significantly
from `redacted` mode.

*Implementation details:*
This PR introduces a new `confmap.WithUnredacted()` `MarshalOption` and
an `unredactedStringer` interface within the `mapstructure` encoder.
This allows the configuration to be marshaled natively without
redaction, preserving all default values while cleanly decoupling the
encoder from `configopaque`. The previous recursive post-processing
workaround has been entirely removed.

**Link to tracking issue**

Fixes #14750

**Testing**

* Removed obsolete tests related to the recursive workaround.
* Updated `TestPrintCommand` in `command_print_test.go` to assert
default values are correctly handled natively in `unredacted` mode.
* Passed `make test` locally.

**Documentation**

* Added `.chloggen` entry.

---------

Signed-off-by: EdgeN8v <ckx19921555595@gmail.com>
Co-authored-by: Damien Mathieu <42@dmathieu.com>
Co-authored-by: Vihas Makwana <121151420+VihasMakwana@users.noreply.github.com>
Co-authored-by: Pablo Baeyens <pablo.baeyens@datadoghq.com>

Author: 4 people

.chloggen/fix-unredacted-defaults.yaml

@@ -0,0 +1,7 @@
+change_type: bug_fix
+component: pkg/otelcol
+note: Fix missing default values in unredacted print-config command by introducing confmap.WithUnredacted MarshalOption.
+subtext: |
+  Resolves an issue where the unredacted mode output omitted all default-valued options. By introducing a new MarshalOption to disable redaction directly at the confmap encoding level, the unredacted mode now preserves all component defaults natively without requiring post-processing.
+issues: [14750]
+change_logs: [user]

confmap/internal/encoder.go

@@ -14,13 +14,22 @@ import (
 // EncoderConfig returns a default encoder.EncoderConfig that includes
 // an EncodeHook that handles both TextMarshaler and Marshaler
 // interfaces.
-func EncoderConfig(rawVal any, _ MarshalOptions) *encoder.EncoderConfig {
+func EncoderConfig(rawVal any, opts MarshalOptions) *encoder.EncoderConfig {
+	hooks := []mapstructure.DecodeHookFunc{
+		encoder.YamlMarshalerHookFunc(),
+	}
+
+	if opts.OpaqueUnredacted {
+		hooks = append(hooks, encoder.StringTextUnredactedHookFunc())
+	}
+
+	hooks = append(hooks,
+		encoder.TextMarshalerHookFunc(),
+		marshalerHookFunc(rawVal),
+	)
+
 	return &encoder.EncoderConfig{
-		EncodeHook: mapstructure.ComposeDecodeHookFunc(
-			encoder.YamlMarshalerHookFunc(),
-			encoder.TextMarshalerHookFunc(),
-			marshalerHookFunc(rawVal),
-		),
+		EncodeHook: mapstructure.ComposeDecodeHookFunc(hooks...),
 	}
 }
 

confmap/internal/encoder_test.go

@@ -0,0 +1,16 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal // import "go.opentelemetry.io/collector/confmap/internal"
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestEncoderConfigUnredacted(t *testing.T) {
+	opts := MarshalOptions{OpaqueUnredacted: true}
+	cfg := EncoderConfig(nil, opts)
+	require.NotNil(t, cfg)
+}

confmap/internal/mapstructure/encoder.go

@@ -268,3 +268,19 @@ func YamlMarshalerHookFunc() mapstructure.DecodeHookFuncValue {
 		return from.Interface(), nil
 	}
 }
+
+// StringTextUnredactedHookFunc returns a DecodeHookFuncValue that extracts the underlying
+// unredacted string from custom string types that implement encoding.TextMarshaler.
+func StringTextUnredactedHookFunc() mapstructure.DecodeHookFuncValue {
+	return func(from, _ reflect.Value) (any, error) {
+		// If the underlying kind is a string, and it implements TextMarshaler
+		// (which obfuscated types like configopaque.String usually do).
+		if from.Kind() == reflect.String {
+			if _, ok := from.Interface().(encoding.TextMarshaler); ok {
+				// Extract the raw string via reflection, bypassing any custom methods.
+				return from.String(), nil
+			}
+		}
+		return from.Interface(), nil
+	}
+}

confmap/internal/mapstructure/encoder_test.go

@@ -14,6 +14,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+type obfuscatedTestString string
+
 type TestComplexStruct struct {
 	Skipped               TestEmptyStruct             `mapstructure:",squash"`
 	Nested                TestSimpleStruct            `mapstructure:",squash"`
@@ -392,3 +394,24 @@ func testHookFunc() mapstructure.DecodeHookFuncValue {
 		return got.skipped, nil
 	}
 }
+
+func (m obfuscatedTestString) MarshalText() ([]byte, error) {
+	return []byte("[REDACTED]"), nil
+}
+
+func TestStringTextUnredactedHookFunc(t *testing.T) {
+	hook := StringTextUnredactedHookFunc()
+
+	val, err := hook(reflect.ValueOf(123), reflect.Value{})
+	require.NoError(t, err)
+	require.Equal(t, 123, val)
+
+	val, err = hook(reflect.ValueOf("plain"), reflect.Value{})
+	require.NoError(t, err)
+	require.Equal(t, "plain", val)
+
+	testSecret := obfuscatedTestString("secret")
+	val, err = hook(reflect.ValueOf(testSecret), reflect.Value{})
+	require.NoError(t, err)
+	require.Equal(t, "secret", val)
+}

confmap/internal/marshaloption.go

@@ -9,7 +9,10 @@ type MarshalOption interface {
 
 // MarshalOptions is used by (*Conf).Marshal to toggle unmarshaling settings.
 // It is in the `internal` package so experimental options can be added in xconfmap.
-type MarshalOptions struct{}
+type MarshalOptions struct {
+	// OpaqueUnredacted specifies whether opaque strings should be marshaled unredacted.
+	OpaqueUnredacted bool
+}
 
 type MarshalOptionFunc func(*MarshalOptions)
 

confmap/xconfmap/confmap.go

@@ -25,3 +25,11 @@ type ExpandedValue = internal.ExpandedValue
 func ToStringMapRaw(conf *confmap.Conf) map[string]any {
 	return internal.ToStringMapRaw(conf)
 }
+
+// WithUnredacted returns a MarshalOption that configures the confmap to
+// bypass redaction of opaque string values.
+func WithUnredacted() confmap.MarshalOption {
+	return internal.MarshalOptionFunc(func(opts *internal.MarshalOptions) {
+		opts.OpaqueUnredacted = true
+	})
+}

confmap/xconfmap/confmap_test.go

@@ -0,0 +1,21 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package xconfmap
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"go.opentelemetry.io/collector/confmap/internal"
+)
+
+func TestWithUnredacted(t *testing.T) {
+	opt := WithUnredacted()
+	require.NotNil(t, opt)
+
+	opts := &internal.MarshalOptions{}
+	opt.(internal.MarshalOptionFunc)(opts)
+	require.True(t, opts.OpaqueUnredacted)
+}

otelcol/command_print.go

@@ -140,36 +140,31 @@ func (pctx *printContext) getPrintableConfig() (any, error) {
 	return cfg, nil
 }
 
-// printUnredactedConfig prints resolved configuration before interpreting
-// with the intended types for each component, thus it shows the full
-// configuration without considering configuopaque. Use with caution.
+// printUnredactedConfig prints the resolved configuration before interpreting
+// with the intended types for each component. It uses unredacted mode to
+// reveal the full configuration including opaque values. Use with caution.
 func (pctx *printContext) printUnredactedConfig() error {
+	cfg, err := pctx.getPrintableConfig()
+	if err != nil {
+		return err
+	}
+
 	if pctx.validate {
 		// Validation serves prevent revealing invalid data.
-		cfg, err := pctx.getPrintableConfig()
-		if err != nil {
-			return err
-		}
 		if err = xconfmap.Validate(cfg); err != nil {
 			return fmt.Errorf("invalid configuration: %w", err)
 		}
-
 		// Note: we discard the validated configuration.
 	}
-	resolver, err := confmap.NewResolver(pctx.set.ConfigProviderSettings.ResolverSettings)
-	if err != nil {
-		return fmt.Errorf("failed to create new resolver: %w", err)
-	}
-	conf, err := resolver.Resolve(pctx.cmd.Context())
-	if err != nil {
-		return fmt.Errorf("error while resolving config: %w", err)
+
+	confMap := confmap.New()
+	if err := confMap.Marshal(cfg, xconfmap.WithUnredacted()); err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
 	}
-	return pctx.printConfigData(conf.ToStringMap())
+
+	return pctx.printConfigData(confMap.ToStringMap())
 }
 
-// printRedactedConfig prints resolved configuration with its assigned
-// types, but without validation. Notably, configopaque strings are printed
-// as "[redacted]". This is the default.
 func (pctx *printContext) printRedactedConfig() error {
 	cfg, err := pctx.getPrintableConfig()
 	if err != nil {

otelcol/command_print_test.go

@@ -75,7 +75,7 @@ func TestPrintCommand(t *testing.T) {
 			name:            "invalid syntax without validate",
 			path:            invalidConfig1,
 			errString:       "'timeout' time: invalid duration",
-			errOnlyRedacted: true,
+			errOnlyRedacted: false,
 		},
 		{
 			name:      "validation fail",
@@ -101,23 +101,17 @@ func TestPrintCommand(t *testing.T) {
 			name: "default field value",
 			path: defaultConfig,
 			outString: map[string]string{
-				"redacted": `timeout: 1s`,
-
-				// Since the structure is empty before
-				// interpretation, no default is expanded.
-				"unredacted": `e: null`,
+				"redacted":   `timeout: 1s`,
+				"unredacted": `timeout: 1s`,
 			},
 		},
 		{
 			name: "field is set json",
 			ofmt: "json",
 			path: validConfig,
 			outString: map[string]string{
-				// Note: JSON does not format as a time.Duration
-				"redacted": `"timeout": 5000000000`,
-
-				// Note: the original input is "5s"
-				"unredacted": `"timeout": "5s"`,
+				"redacted":   `"timeout": 5000000000`,
+				"unredacted": `"timeout": 5000000000`,
 			},
 		},
 		{
@@ -132,12 +126,8 @@ func TestPrintCommand(t *testing.T) {
 			name: "opaque default",
 			path: defaultConfig,
 			outString: map[string]string{
-				"redacted": `opaque: '[REDACTED]'`,
-
-				// Note: the default opaque value does not print,
-				// the other value is set in defaultConfig so that
-				// the whole component config is not defaulted.
-				"unredacted": `other: lala`,
+				"redacted":   `opaque: '[REDACTED]'`,
+				"unredacted": `opaque: "1234"`,
 			},
 		},
 	}