(bugfix) log level does not change when standalone agent is reloaded or when otel runtime is used

internal/pkg/agent/application/coordinator/coordinator.go

@@ -1673,6 +1673,22 @@ func (c *Coordinator) processConfigAgent(ctx context.Context, cfg *config.Config
 	}
 	c.currentCfg = currentCfg
 
+	// check if log level has changed in standalone agent config
+	ll := currentCfg.Settings.LoggingConfig.Level
+	if ll != c.state.LogLevel {
+		// set log level for the coordinator
+		c.setLogLevel(ll)
+		// set global log level
+		logger.SetLevel(ll)
+		// set agent log level.
+		// this is used by other parts of the agent to report the log level eg. otel manager
+		err = c.agentInfo.SetLogLevel(ctx, ll.String())
+		if err != nil {
+			c.logger.Errorf("failed to set agent log level: %v", err)
+		}
+		c.logger.Infof("log level changed to %s", ll.String())
+	}
+
 	if c.vars != nil {
 		return c.refreshComponentModel(ctx)
 	}
@@ -1801,10 +1817,13 @@ func (c *Coordinator) processVars(ctx context.Context, vars []*transpiler.Vars)
 
 // Called on the main Coordinator goroutine.
 func (c *Coordinator) processLogLevel(ctx context.Context, ll logp.Level) {
-	c.setLogLevel(ll)
-	err := c.refreshComponentModel(ctx)
-	if err != nil {
-		c.logger.Errorf("updating log level: %s", err.Error())
+	// do not refresh component model if log level did not change
+	if c.state.LogLevel != ll {
+		c.setLogLevel(ll)
+		err := c.refreshComponentModel(ctx)
+		if err != nil {
+			c.logger.Errorf("updating log level: %s", err.Error())
+		}
 	}
 }
 

internal/pkg/otel/manager/execution.go

@@ -25,7 +25,7 @@ type collectorExecution interface {
 	//   - errCh: Process exit errors are sent to the errCh channel
 	//   - statusCh: Collector's status updates are sent to statusCh channel.
 	//   - forceFetchStatusCh: Channel that is used to trigger a forced status update.
-	startCollector(ctx context.Context, baseLogger *logger.Logger, logger *logger.Logger, cfg *confmap.Conf, errCh chan error, statusCh chan *status.AggregateStatus, forceFetchStatusCh chan struct{}) (collectorHandle, error)
+	startCollector(ctx context.Context, logLevel string, baseLogger *logger.Logger, logger *logger.Logger, cfg *confmap.Conf, errCh chan error, statusCh chan *status.AggregateStatus, forceFetchStatusCh chan struct{}) (collectorHandle, error)
 }
 
 type collectorHandle interface {

internal/pkg/otel/manager/execution_subprocess.go

@@ -51,7 +51,6 @@ func newSubprocessExecution(logLevel logp.Level, collectorPath string, uuid stri
 		collectorPath: collectorPath,
 		collectorArgs: []string{
 			fmt.Sprintf("--%s", OtelSetSupervisedFlagName),
-			fmt.Sprintf("--%s=%s", OtelSupervisedLoggingLevelFlagName, logLevel.String()),
 			fmt.Sprintf("--%s=%s", OtelSupervisedMonitoringURLFlagName, monitoring.EDOTMonitoringEndpoint()),
 		},
 		logLevel:                 logLevel,
@@ -62,6 +61,7 @@ func newSubprocessExecution(logLevel logp.Level, collectorPath string, uuid stri
 	}, nil
 }
 
+// subprocessExecution implements collectorExecution by running the collector in a subprocess.
 type subprocessExecution struct {
 	collectorPath            string
 	collectorArgs            []string
@@ -74,7 +74,20 @@ type subprocessExecution struct {
 
 // startCollector starts a supervised collector and monitors its health. Process exit errors are sent to the
 // processErrCh channel. Other run errors, such as not able to connect to the health endpoint, are sent to the runErrCh channel.
-func (r *subprocessExecution) startCollector(ctx context.Context, baseLogger *logger.Logger, logger *logger.Logger, cfg *confmap.Conf, processErrCh chan error, statusCh chan *status.AggregateStatus, forceFetchStatusCh chan struct{}) (collectorHandle, error) {
+func (r *subprocessExecution) startCollector(
+	ctx context.Context,
+	logLevel string,
+	baseLogger *logger.Logger,
+	logger *logger.Logger,
+	cfg *confmap.Conf,
+	processErrCh chan error,
+	statusCh chan *status.AggregateStatus,
+	forceFetchStatusCh chan struct{},
+) (collectorHandle, error) {
+	if err := r.setLogLevelFromString(logLevel); err != nil {
+		return nil, fmt.Errorf("failed to set log level for otel collector: %w", err)
+	}
+
 	if cfg == nil {
 		// configuration is required
 		return nil, errors.New("no configuration provided")
@@ -115,8 +128,12 @@ func (r *subprocessExecution) startCollector(ctx context.Context, baseLogger *lo
 	env := os.Environ()
 	// Set the environment variable for the collector metrics port. See comment at the constant definition for more information.
 	env = append(env, fmt.Sprintf("%s=%d", componentmonitoring.OtelCollectorMetricsPortEnvVarName, collectorMetricsPort))
+
+	// set collector args
+	collectorArgs := append(r.collectorArgs, fmt.Sprintf("--%s=%s", OtelSupervisedLoggingLevelFlagName, r.logLevel.String()))
+
 	processInfo, err := process.Start(r.collectorPath,
-		process.WithArgs(r.collectorArgs),
+		process.WithArgs(collectorArgs),
 		process.WithEnv(env),
 		process.WithCmdOptions(func(c *exec.Cmd) error {
 			c.Stdin = bytes.NewReader(confBytes)
@@ -241,6 +258,18 @@ func (r *subprocessExecution) startCollector(ctx context.Context, baseLogger *lo
 	return ctl, nil
 }
 
+func (r *subprocessExecution) setLogLevelFromString(logLevel string) error {
+	var lvl logp.Level
+	err := lvl.Unpack(logLevel)
+	if err != nil {
+		return fmt.Errorf("invalid log level '%s': %w", logLevel, err)
+	}
+	if r.logLevel != lvl {
+		r.logLevel = lvl
+	}
+	return nil
+}
+
 // cloneCollectorStatus creates a deep copy of the provided AggregateStatus.
 func cloneCollectorStatus(aStatus *status.AggregateStatus) *status.AggregateStatus {
 	if aStatus == nil {

internal/pkg/otel/manager/manager.go

@@ -223,7 +223,7 @@ func (m *OTelManager) Run(ctx context.Context) error {
 
 			newRetries := m.recoveryRetries.Add(1)
 			m.logger.Infof("collector recovery restarting, total retries: %d", newRetries)
-			m.proc, err = m.execution.startCollector(ctx, m.baseLogger, m.logger, m.mergedCollectorCfg, m.collectorRunErr, collectorStatusCh, forceFetchStatusCh)
+			m.proc, err = m.execution.startCollector(ctx, m.agentInfo.LogLevel(), m.baseLogger, m.logger, m.mergedCollectorCfg, m.collectorRunErr, collectorStatusCh, forceFetchStatusCh)
 			if err != nil {
 				// report a startup error (this gets reported as status)
 				m.reportStartupErr(ctx, err)
@@ -253,7 +253,7 @@ func (m *OTelManager) Run(ctx context.Context) error {
 
 				// in this rare case the collector stopped running but a configuration was
 				// provided and the collector stopped with a clean exit
-				m.proc, err = m.execution.startCollector(ctx, m.baseLogger, m.logger, m.mergedCollectorCfg, m.collectorRunErr, collectorStatusCh, forceFetchStatusCh)
+				m.proc, err = m.execution.startCollector(ctx, m.agentInfo.LogLevel(), m.baseLogger, m.logger, m.mergedCollectorCfg, m.collectorRunErr, collectorStatusCh, forceFetchStatusCh)
 				if err != nil {
 					// report a startup error (this gets reported as status)
 					m.reportStartupErr(ctx, err)
@@ -368,6 +368,13 @@ func buildMergedConfig(
 		if err != nil {
 			return nil, fmt.Errorf("failed to generate otel config: %w", err)
 		}
+
+		// get log level from agent info
+		level := translate.GetOTelLogLevel(agentInfo.LogLevel())
+		if err := componentOtelCfg.Merge(confmap.NewFromStringMap(map[string]any{"service::telemetry::logs::level": level})); err != nil {
+			return nil, fmt.Errorf("failed to set log level in otel config: %w", err)
+		}
+
 	}
 
 	// If both configs are nil, return nil so the manager knows to stop the collector
@@ -451,7 +458,7 @@ func (m *OTelManager) applyMergedConfig(ctx context.Context, collectorStatusCh c
 	} else {
 		// either a new configuration or the first configuration
 		// that results in the collector being started
-		proc, err := m.execution.startCollector(ctx, m.baseLogger, m.logger, m.mergedCollectorCfg, collectorRunErr, collectorStatusCh, forceFetchStatusCh)
+		proc, err := m.execution.startCollector(ctx, m.agentInfo.LogLevel(), m.baseLogger, m.logger, m.mergedCollectorCfg, collectorRunErr, collectorStatusCh, forceFetchStatusCh)
 		if err != nil {
 			// failed to create the collector (this is different then
 			// it's failing to run). we do not retry creation on failure

internal/pkg/otel/manager/manager_test.go

@@ -91,12 +91,12 @@ type testExecution struct {
 	handle collectorHandle
 }
 
-func (e *testExecution) startCollector(ctx context.Context, baseLogger *logger.Logger, logger *logger.Logger, cfg *confmap.Conf, errCh chan error, statusCh chan *status.AggregateStatus, forceFetchStatusCh chan struct{}) (collectorHandle, error) {
+func (e *testExecution) startCollector(ctx context.Context, level string, baseLogger *logger.Logger, logger *logger.Logger, cfg *confmap.Conf, errCh chan error, statusCh chan *status.AggregateStatus, forceFetchStatusCh chan struct{}) (collectorHandle, error) {
 	e.mtx.Lock()
 	defer e.mtx.Unlock()
 
 	var err error
-	e.handle, err = e.exec.startCollector(ctx, baseLogger, logger, cfg, errCh, statusCh, forceFetchStatusCh)
+	e.handle, err = e.exec.startCollector(ctx, "info", baseLogger, logger, cfg, errCh, statusCh, forceFetchStatusCh)
 	return e.handle, err
 }
 
@@ -118,6 +118,7 @@ type mockExecution struct {
 
 func (e *mockExecution) startCollector(
 	ctx context.Context,
+	level string,
 	_ *logger.Logger,
 	_ *logger.Logger,
 	cfg *confmap.Conf,

internal/pkg/otel/translate/otelconfig.go

@@ -145,6 +145,24 @@ func GetOtelConfig(
 	return otelConfig, nil
 }
 
+func GetOTelLogLevel(level string) string {
+	if level != "" {
+		switch strings.ToLower(level) {
+		case "debug":
+			return "DEBUG"
+		case "info":
+			return "INFO"
+		case "warning":
+			return "WARN"
+		case "error":
+			return "ERROR"
+		default:
+			return "INFO"
+		}
+	}
+	return "INFO"
+}
+
 // VerifyComponentIsOtelSupported verifies that the given component can be run in an Otel Collector. It returns an error
 // indicating what the problem is, if it can't.
 func VerifyComponentIsOtelSupported(comp *component.Component) error {