tfsdklog: Ensure sink logger options are propagated to SDK and provider root loggers

.changelog/58.txt

@@ -0,0 +1,3 @@
+```release-note:bug
+tflog+tfsdklog: Prevented `Unable to create logging subsystem with AdditionalLocationOffset due to missing root logger options` warning logs during acceptance testing
+```

internal/logging/log.go

@@ -41,6 +41,12 @@ const (
 	// SinkKey is the loggerKey that will hold the logging sink used for
 	// test frameworks.
 	SinkKey loggerKey = ""
+
+	// SinkOptionsKey is the loggerKey that will hold the sink
+	// logger options when the SDK provider logger is created. This is to
+	// assist creating subsystem loggers, as most options cannot be fetched and
+	// a logger does not provide set methods for these options.
+	SinkOptionsKey loggerKey = "sink-options"
 )
 
 var (

internal/logging/sink.go

@@ -0,0 +1,51 @@
+package logging
+
+import (
+	"context"
+
+	"github.com/hashicorp/go-hclog"
+)
+
+// GetSink returns the sink logger used for writing logs.
+// If no sink logger has been created, it will return nil.
+func GetSink(ctx context.Context) hclog.Logger {
+	logger := ctx.Value(SinkKey)
+	if logger == nil {
+		return nil
+	}
+	return logger.(hclog.Logger)
+}
+
+// GetSinkOptions returns the root logger options used for
+// creating the root SDK logger. If the root logger has not been created or
+// the options are not present, it will return nil.
+func GetSinkOptions(ctx context.Context) *hclog.LoggerOptions {
+	if GetSink(ctx) == nil {
+		return nil
+	}
+
+	loggerOptionsRaw := ctx.Value(SinkOptionsKey)
+
+	if loggerOptionsRaw == nil {
+		return nil
+	}
+
+	loggerOptions, ok := loggerOptionsRaw.(*hclog.LoggerOptions)
+
+	if !ok {
+		return nil
+	}
+
+	return loggerOptions
+}
+
+// SetSink sets `logger` as the sink logger used for writing logs.
+func SetSink(ctx context.Context, logger hclog.Logger) context.Context {
+	return context.WithValue(ctx, SinkKey, logger)
+}
+
+// SetSinkOptions sets `loggerOptions` as the root logger options
+// used for creating the SDK root logger.
+func SetSinkOptions(ctx context.Context, loggerOptions *hclog.LoggerOptions) context.Context {
+	return context.WithValue(ctx, SinkOptionsKey, loggerOptions)
+}

tfsdklog/sdk.go

@@ -15,12 +15,21 @@ func NewRootSDKLogger(ctx context.Context, options ...logging.Option) context.Co
 	if opts.Name == "" {
 		opts.Name = logging.DefaultSDKRootLoggerName
 	}
-	if sink := getSink(ctx); sink != nil {
+	if sink := logging.GetSink(ctx); sink != nil {
 		logger := sink.Named(opts.Name)
+		sinkLoggerOptions := logging.GetSinkOptions(ctx)
+		sdkLoggerOptions := hclogutils.LoggerOptionsCopy(sinkLoggerOptions)
+		sdkLoggerOptions.Name = opts.Name
+
 		if opts.Level != hclog.NoLevel {
 			logger.SetLevel(opts.Level)
+			sdkLoggerOptions.Level = opts.Level
 		}
-		return logging.SetSDKRootLogger(ctx, logger)
+
+		ctx = logging.SetSDKRootLogger(ctx, logger)
+		ctx = logging.SetSDKRootLoggerOptions(ctx, sdkLoggerOptions)
+
+		return ctx
 	}
 	if opts.Level == hclog.NoLevel {
 		opts.Level = hclog.Trace
@@ -49,12 +58,21 @@ func NewRootProviderLogger(ctx context.Context, options ...logging.Option) conte
 	if opts.Name == "" {
 		opts.Name = logging.DefaultProviderRootLoggerName
 	}
-	if sink := getSink(ctx); sink != nil {
+	if sink := logging.GetSink(ctx); sink != nil {
 		logger := sink.Named(opts.Name)
+		sinkLoggerOptions := logging.GetSinkOptions(ctx)
+		providerLoggerOptions := hclogutils.LoggerOptionsCopy(sinkLoggerOptions)
+		providerLoggerOptions.Name = opts.Name
+
 		if opts.Level != hclog.NoLevel {
 			logger.SetLevel(opts.Level)
+			providerLoggerOptions.Level = opts.Level
 		}
-		return logging.SetProviderRootLogger(ctx, logger)
+
+		ctx = logging.SetProviderRootLogger(ctx, logger)
+		ctx = logging.SetProviderRootLoggerOptions(ctx, providerLoggerOptions)
+
+		return ctx
 	}
 	if opts.Level == hclog.NoLevel {
 		opts.Level = hclog.Trace

tfsdklog/sink.go

@@ -57,14 +57,6 @@ var ValidLevels = []string{"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "OFF"}
 // Only show invalid log level message once across any number of level lookups.
 var invalidLogLevelMessage sync.Once
 
-func getSink(ctx context.Context) hclog.Logger {
-	logger := ctx.Value(logging.SinkKey)
-	if logger == nil {
-		return nil
-	}
-	return logger.(hclog.Logger)
-}
-
 // RegisterTestSink sets up a logging sink, for use with test frameworks and
 // other cases where plugin logs don't get routed through Terraform. This
 // applies the same filtering and file output behaviors that Terraform does.
@@ -75,10 +67,15 @@ func getSink(ctx context.Context) hclog.Logger {
 // RegisterTestSink must be called prior to any loggers being setup or
 // instantiated.
 func RegisterTestSink(ctx context.Context, t testing.T) context.Context {
-	return context.WithValue(ctx, logging.SinkKey, newSink(t))
+	logger, loggerOptions := newSink(t)
+
+	ctx = logging.SetSink(ctx, logger)
+	ctx = logging.SetSinkOptions(ctx, loggerOptions)
+
+	return ctx
 }
 
-func newSink(t testing.T) hclog.Logger {
+func newSink(t testing.T) (hclog.Logger, *hclog.LoggerOptions) {
 	logOutput := io.Writer(os.Stderr)
 	var json bool
 	var logLevel hclog.Level
@@ -134,12 +131,14 @@ func newSink(t testing.T) hclog.Logger {
 		})
 	}
 
-	return hclog.New(&hclog.LoggerOptions{
+	loggerOptions := &hclog.LoggerOptions{
 		Level:             logLevel,
 		Output:            logOutput,
 		IndependentLevels: true,
 		JSONFormat:        json,
-	})
+	}
+
+	return hclog.New(loggerOptions), loggerOptions
 }
 
 func isValidLogLevel(level string) bool {