diff --git a/filebeat/tests/integration/filebeat_test.go b/filebeat/tests/integration/filebeat_test.go
index b0a38ef38171..58208f2d7b40 100644
--- a/filebeat/tests/integration/filebeat_test.go
+++ b/filebeat/tests/integration/filebeat_test.go
@@ -87,7 +87,7 @@ func TestFilebeatRunsAndLogsJSONToFile(t *testing.T) {
 		line := r.Bytes()
 		m := map[string]any{}
 		if err := json.Unmarshal(line, &m); err != nil {
-			t.Fatalf("line %d is not a valid JSON: %s", count, err)
+			t.Fatalf("line %d is not a valid JSON: %s: %s", count, err, string(line))
 		}
 		count++
 	}
diff --git a/libbeat/api/server.go b/libbeat/api/server.go
index 561ab47457da..4e342997b0f0 100644
--- a/libbeat/api/server.go
+++ b/libbeat/api/server.go
@@ -41,10 +41,6 @@ type Server struct {
 
 // New creates a new API Server with no routes attached.
 func New(log *logp.Logger, config *config.C) (*Server, error) {
-	if log == nil {
-		log = logp.NewLogger("")
-	}
-
 	cfg := DefaultConfig
 	err := config.Unpack(&cfg)
 	if err != nil {
diff --git a/libbeat/api/server_test.go b/libbeat/api/server_test.go
index 8ba0e655e392..f5eb7a839b47 100644
--- a/libbeat/api/server_test.go
+++ b/libbeat/api/server_test.go
@@ -31,9 +31,11 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/elastic/elastic-agent-libs/config"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 )
 
 func TestConfiguration(t *testing.T) {
+	logger := logptest.NewTestingLogger(t, "")
 	if runtime.GOOS != "windows" {
 		t.Skip("Check for User and Security Descriptor")
 		return
@@ -44,7 +46,7 @@ func TestConfiguration(t *testing.T) {
 			"user": "admin",
 		})
 
-		_, err := New(nil, cfg)
+		_, err := New(logger, cfg)
 		require.Error(t, err)
 	})
 
@@ -54,12 +56,14 @@ func TestConfiguration(t *testing.T) {
 			"security_descriptor": "D:P(A;;GA;;;1234)",
 		})
 
-		_, err := New(nil, cfg)
+		_, err := New(logger, cfg)
 		require.Error(t, err)
 	})
 }
 
 func TestSocket(t *testing.T) {
+	logger := logptest.NewTestingLogger(t, "")
+
 	if runtime.GOOS == "windows" {
 		t.Skip("Unix Sockets don't work under windows")
 		return
@@ -87,7 +91,7 @@ func TestSocket(t *testing.T) {
 			"host": "unix://" + sockFile,
 		})
 
-		s, err := New(nil, cfg)
+		s, err := New(logger, cfg)
 		require.NoError(t, err)
 		attachEchoHelloHandler(t, s)
 		go s.Start()
@@ -130,7 +134,7 @@ func TestSocket(t *testing.T) {
 			"host": "unix://" + sockFile,
 		})
 
-		s, err := New(nil, cfg)
+		s, err := New(logger, cfg)
 		require.NoError(t, err)
 		attachEchoHelloHandler(t, s)
 		go s.Start()
@@ -166,8 +170,8 @@ func TestHTTP(t *testing.T) {
 	cfg := config.MustNewConfigFrom(map[string]interface{}{
 		"host": url,
 	})
-
-	s, err := New(nil, cfg)
+	logger := logptest.NewTestingLogger(t, "")
+	s, err := New(logger, cfg)
 	require.NoError(t, err)
 	attachEchoHelloHandler(t, s)
 	go s.Start()
@@ -198,7 +202,8 @@ func TestAttachHandler(t *testing.T) {
 		"host": "http://localhost:0",
 	})
 
-	s, err := New(nil, cfg)
+	logger := logptest.NewTestingLogger(t, "")
+	s, err := New(logger, cfg)
 	require.NoError(t, err)
 
 	req := httptest.NewRequest(http.MethodGet, "http://"+s.l.Addr().String()+"/test", nil)
diff --git a/libbeat/beat/info.go b/libbeat/beat/info.go
index 896259541f3c..f47b67d4d8d8 100644
--- a/libbeat/beat/info.go
+++ b/libbeat/beat/info.go
@@ -23,6 +23,7 @@ import (
 	"github.com/gofrs/uuid/v5"
 	"go.opentelemetry.io/collector/consumer"
 
+	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/monitoring"
 )
 
@@ -46,6 +47,7 @@ type Info struct {
 	Monitoring           Monitoring
 	LogConsumer          consumer.Logs // otel log consumer
 	UseDefaultProcessors bool          // Whether to use the default processors
+	Logger               *logp.Logger
 }
 
 type Monitoring struct {
diff --git a/libbeat/cmd/instance/beat.go b/libbeat/cmd/instance/beat.go
index 2936c1b75b25..0feeb50b766f 100644
--- a/libbeat/cmd/instance/beat.go
+++ b/libbeat/cmd/instance/beat.go
@@ -175,8 +175,6 @@ func defaultCertReloadConfig() certReloadConfig {
 	}
 }
 
-var debugf = logp.MakeDebug("beat")
-
 // Run initializes and runs a Beater implementation. name is the name of the
 // Beat (e.g. packetbeat or metricbeat). version is version number of the Beater
 // implementation. bt is the `Creator` callback for creating a new beater
@@ -329,9 +327,9 @@ func (b *Beat) createBeater(bt beat.Creator) (beat.Beater, error) {
 		return nil, err
 	}
 
-	log := logp.NewLogger("beat")
+	log := b.Info.Logger.Named("beat")
 	log.Infof("Setup Beat: %s; Version: %s", b.Info.Beat, b.Info.Version)
-	b.logSystemInfo(log)
+	b.logSystemInfo()
 
 	err = b.registerESVersionCheckCallback()
 	if err != nil {
@@ -350,7 +348,7 @@ func (b *Beat) createBeater(bt beat.Creator) (beat.Beater, error) {
 		reg = monitoring.Default.NewRegistry("libbeat")
 	}
 
-	err = metricreport.SetupMetrics(logp.NewLogger("metrics"), b.Info.Beat, version.GetDefaultVersion())
+	err = metricreport.SetupMetrics(b.Beat.Info.Logger.Named("metrics"), b.Info.Beat, version.GetDefaultVersion())
 	if err != nil {
 		return nil, err
 	}
@@ -359,14 +357,14 @@ func (b *Beat) createBeater(bt beat.Creator) (beat.Beater, error) {
 	mgmt := b.Info.Monitoring.StateRegistry.NewRegistry("management")
 	monitoring.NewBool(mgmt, "enabled").Set(b.Manager.Enabled())
 
-	debugf("Initializing output plugins")
+	log.Debug("Initializing output plugins")
 	outputEnabled := b.Config.Output.IsSet() && b.Config.Output.Config().Enabled()
 	if !outputEnabled {
 		if b.Manager.Enabled() {
-			logp.Info("Output is configured through Central Management")
+			b.Info.Logger.Info("Output is configured through Central Management")
 		} else {
 			msg := "no outputs are defined, please define one under the output section"
-			logp.Info("%s", msg)
+			b.Info.Logger.Info("%s", msg)
 			return nil, errors.New(msg)
 		}
 	}
@@ -375,7 +373,7 @@ func (b *Beat) createBeater(bt beat.Creator) (beat.Beater, error) {
 	monitors := pipeline.Monitors{
 		Metrics:   reg,
 		Telemetry: b.Info.Monitoring.StateRegistry,
-		Logger:    logp.L().Named("publisher"),
+		Logger:    b.Info.Logger.Named("publisher"),
 		Tracer:    b.Instrumentation.Tracer(),
 	}
 	outputFactory := b.MakeOutputFactory(b.Config.Output)
@@ -404,14 +402,15 @@ func (b *Beat) createBeater(bt beat.Creator) (beat.Beater, error) {
 }
 
 func (b *Beat) launch(settings Settings, bt beat.Creator) error {
+	logger := b.Info.Logger
 	defer func() {
-		_ = logp.Sync()
+		_ = logger.Sync()
 	}()
-	defer logp.Info("%s stopped.", b.Info.Beat)
+	defer logger.Infof("%s stopped.", b.Info.Beat)
 
 	defer func() {
 		if err := b.processors.Close(); err != nil {
-			logp.Warn("Failed to close global processing: %v", err)
+			logger.Warnf("Failed to close global processing: %v", err)
 		}
 	}()
 
@@ -433,7 +432,7 @@ func (b *Beat) launch(settings Settings, bt beat.Creator) error {
 			_ = bl.Unlock()
 		}()
 	} else {
-		logp.Info("running under elastic-agent, per-beat lockfiles disabled")
+		logger.Info("running under elastic-agent, per-beat lockfiles disabled")
 	}
 
 	svc.BeforeRun()
@@ -446,7 +445,7 @@ func (b *Beat) launch(settings Settings, bt beat.Creator) error {
 	// that would be set at runtime.
 	if b.Config.HTTP.Enabled() {
 		var err error
-		b.API, err = api.NewWithDefaultRoutes(logp.NewLogger(""), b.Config.HTTP, api.NamespaceLookupFunc())
+		b.API, err = api.NewWithDefaultRoutes(logger, b.Config.HTTP, api.NamespaceLookupFunc())
 		if err != nil {
 			return fmt.Errorf("could not start the HTTP server for the API: %w", err)
 		}
@@ -530,7 +529,7 @@ func (b *Beat) launch(settings Settings, bt beat.Creator) error {
 		return err
 	}
 
-	logp.Info("%s start running.", b.Info.Beat)
+	logger.Infof("%s start running.", b.Info.Beat)
 
 	err = beater.Run(&b.Beat)
 	if b.shouldReexec {
@@ -776,12 +775,6 @@ func (b *Beat) configure(settings Settings) error {
 		config.OverwriteConfigOpts(configOptsWithKeystore(store))
 	}
 
-	instrumentation, err := instrumentation.New(cfg, b.Info.Beat, b.Info.Version)
-	if err != nil {
-		return err
-	}
-	b.Beat.Instrumentation = instrumentation
-
 	b.keystore = store
 	b.Beat.Keystore = store
 	err = cloudid.OverwriteSettings(cfg)
@@ -795,7 +788,7 @@ func (b *Beat) configure(settings Settings) error {
 		return fmt.Errorf("error unpacking config data: %w", err)
 	}
 
-	if err := PromoteOutputQueueSettings(&b.Config); err != nil {
+	if err := PromoteOutputQueueSettings(b); err != nil {
 		return fmt.Errorf("could not promote output queue settings: %w", err)
 	}
 
@@ -814,12 +807,22 @@ func (b *Beat) configure(settings Settings) error {
 		return fmt.Errorf("error setting timestamp precision: %w", err)
 	}
 
-	if err := configure.LoggingWithTypedOutputs(b.Info.Beat, b.Config.Logging, b.Config.EventLogging, logp.TypeKey, logp.EventType); err != nil {
+	b.Info.Logger, err = configure.LoggingWithTypedOutputsLocal(b.Info.Beat, b.Config.Logging, b.Config.EventLogging, logp.TypeKey, logp.EventType)
+	if err != nil {
 		return fmt.Errorf("error initializing logging: %w", err)
 	}
 
+	// extracting here for ease of use
+	logger := b.Info.Logger
+
+	instrumentation, err := instrumentation.New(cfg, b.Info.Beat, b.Info.Version, b.Info.Logger)
+	if err != nil {
+		return err
+	}
+	b.Beat.Instrumentation = instrumentation
+
 	// log paths values to help with troubleshooting
-	logp.Info("%s", paths.Paths.String())
+	logger.Infof("%s", paths.Paths.String())
 
 	metaPath := paths.Resolve(paths.Data, "meta.json")
 	err = b.LoadMeta(metaPath)
@@ -827,7 +830,7 @@ func (b *Beat) configure(settings Settings) error {
 		return err
 	}
 
-	logp.Info("Beat ID: %v", b.Info.ID)
+	logger.Infof("Beat ID: %v", b.Info.ID)
 
 	// Try to get the host's FQDN and set it.
 	h, err := sysinfo.Host()
@@ -842,7 +845,7 @@ func (b *Beat) configure(settings Settings) error {
 	if err != nil {
 		// FQDN lookup is "best effort".  We log the error, fallback to
 		// the OS-reported hostname, and move on.
-		logp.Warn("unable to lookup FQDN: %s, using hostname = %s as FQDN", err.Error(), b.Info.Hostname)
+		logger.Infof("unable to lookup FQDN: %s, using hostname = %s as FQDN", err.Error(), b.Info.Hostname)
 		b.Info.FQDN = b.Info.Hostname
 	} else {
 		b.Info.FQDN = fqdn
@@ -877,11 +880,11 @@ func (b *Beat) configure(settings Settings) error {
 	}
 
 	if maxProcs := b.Config.MaxProcs; maxProcs > 0 {
-		logp.Info("Set max procs limit: %v", maxProcs)
+		logger.Infof("Set max procs limit: %v", maxProcs)
 		runtime.GOMAXPROCS(maxProcs)
 	}
 	if gcPercent := b.Config.GCPercent; gcPercent > 0 {
-		logp.Info("Set gc percentage to: %v", gcPercent)
+		logger.Infof("Set gc percentage to: %v", gcPercent)
 		debug.SetGCPercent(gcPercent)
 	}
 
@@ -894,9 +897,9 @@ func (b *Beat) configure(settings Settings) error {
 
 	imFactory := settings.IndexManagement
 	if imFactory == nil {
-		imFactory = idxmgmt.MakeDefaultSupport(settings.ILM)
+		imFactory = idxmgmt.MakeDefaultSupport(settings.ILM, logger)
 	}
-	b.IdxSupporter, err = imFactory(nil, b.Beat.Info, b.RawConfig)
+	b.IdxSupporter, err = imFactory(logger, b.Beat.Info, b.RawConfig)
 	if err != nil {
 		return err
 	}
@@ -905,7 +908,7 @@ func (b *Beat) configure(settings Settings) error {
 	if processingFactory == nil {
 		processingFactory = processing.MakeDefaultBeatSupport(true)
 	}
-	b.processors, err = processingFactory(b.Info, logp.L().Named("processors"), b.RawConfig)
+	b.processors, err = processingFactory(b.Info, logger.Named("processors"), b.RawConfig)
 
 	b.Manager.RegisterDiagnosticHook("global processors", "a list of currently configured global beat processors",
 		"global_processors.txt", "text/plain", b.agentDiagnosticHook)
@@ -914,7 +917,7 @@ func (b *Beat) configure(settings Settings) error {
 			m := monitoring.CollectStructSnapshot(monitoring.Default, monitoring.Full, true)
 			data, err := json.MarshalIndent(m, "", "  ")
 			if err != nil {
-				logp.L().Warnw("Failed to collect beat metric snapshot for Agent diagnostics.", "error", err)
+				logger.Warnw("Failed to collect beat metric snapshot for Agent diagnostics.", "error", err)
 				return []byte(err.Error())
 			}
 			return data
@@ -943,7 +946,7 @@ func (b *Beat) LoadMeta(metaPath string) error {
 		FirstStart time.Time `json:"first_start"`
 	}
 
-	logp.Debug("beat", "Beat metadata path: %v", metaPath)
+	b.Info.Logger.Debugf("beat", "Beat metadata path: %v", metaPath)
 
 	f, err := openRegular(metaPath)
 	if err != nil && !os.IsNotExist(err) {
@@ -1065,7 +1068,7 @@ func (b *Beat) loadDashboards(ctx context.Context, force bool) error {
 		if err != nil {
 			return fmt.Errorf("error importing Kibana dashboards: %w", err)
 		}
-		logp.Info("Kibana dashboards successfully loaded.")
+		b.Info.Logger.Info("Kibana dashboards successfully loaded.")
 	}
 
 	return nil
@@ -1171,7 +1174,7 @@ func (b *Beat) MakeOutputFactory(
 }
 
 func (b *Beat) reloadOutputOnCertChange(cfg config.Namespace) error {
-	logger := logp.L().Named("ssl.cert.reloader")
+	logger := b.Info.Logger.Named("ssl.cert.reloader")
 	// Here the output is created and we have access to the Beat struct (with the manager)
 	// as a workaround we can unpack the new settings and trigger the reload-watcher from here
 
@@ -1360,8 +1363,9 @@ func handleError(err error) error {
 // in debugging. This information includes data about the beat, build, go
 // runtime, host, and process. If any of the data is not available it will be
 // omitted.
-func (b *Beat) logSystemInfo(log *logp.Logger) {
-	defer logp.Recover("An unexpected error occurred while collecting " +
+func (b *Beat) logSystemInfo() {
+	log := b.Beat.Info.Logger
+	defer log.Recover("An unexpected error occurred while collecting " +
 		"information about the system.")
 	log = log.With(logp.Namespace("system_info"))
 
@@ -1527,21 +1531,21 @@ func sanitizeIPs(ips []string) []string {
 	return validIPs
 }
 
-// promoteOutputQueueSettings checks to see if the output
+// PromoteOutputQueueSettings checks to see if the output
 // configuration has queue settings defined and if so it promotes them
 // to the top level queue settings.  This is done to allow existing
 // behavior of specifying queue settings at the top level or like
 // elastic-agent that specifies queue settings under the output
-func PromoteOutputQueueSettings(bc *beatConfig) error {
-	if bc.Output.IsSet() && bc.Output.Config().Enabled() {
+func PromoteOutputQueueSettings(b *Beat) error {
+	if b.Config.Output.IsSet() && b.Config.Output.Config().Enabled() {
 		pc := pipeline.Config{}
-		err := bc.Output.Config().Unpack(&pc)
+		err := b.Config.Output.Config().Unpack(&pc)
 		if err != nil {
 			return fmt.Errorf("error unpacking output queue settings: %w", err)
 		}
 		if pc.Queue.IsSet() {
-			logp.Info("global queue settings replaced with output queue settings")
-			bc.Pipeline.Queue = pc.Queue
+			b.Info.Logger.Info("global queue settings replaced with output queue settings")
+			b.Config.Pipeline.Queue = pc.Queue
 		}
 	}
 	return nil
diff --git a/libbeat/cmd/instance/beat_reexec_other.go b/libbeat/cmd/instance/beat_reexec_other.go
index ceb5b202b44e..4bdd2c8c43b3 100644
--- a/libbeat/cmd/instance/beat_reexec_other.go
+++ b/libbeat/cmd/instance/beat_reexec_other.go
@@ -21,13 +21,11 @@ package instance
 
 import (
 	"runtime"
-
-	"github.com/elastic/elastic-agent-libs/logp"
 )
 
 // doReexec is a noop on Windows, it only logs a message explaining it.
 func (b *Beat) doReexec() error {
-	logger := logp.L().Named("ssl.cert.reloader")
+	logger := b.Info.Logger.Named("ssl.cert.reloader")
 	logger.Info("reloading certs/reexecing is not supported on %s. %s will not restart", runtime.GOOS, b.Info.Beat)
 	return nil
 }
diff --git a/libbeat/cmd/instance/beat_test.go b/libbeat/cmd/instance/beat_test.go
index 2120c7c657b4..e4e2fd8b630d 100644
--- a/libbeat/cmd/instance/beat_test.go
+++ b/libbeat/cmd/instance/beat_test.go
@@ -25,6 +25,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/cfgfile"
 	"github.com/elastic/beats/v7/libbeat/common/reload"
 	"github.com/elastic/beats/v7/libbeat/management/status"
@@ -33,6 +34,7 @@ import (
 	"github.com/elastic/elastic-agent-client/v7/pkg/client"
 	"github.com/elastic/elastic-agent-libs/config"
 	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/go-ucfg/yaml"
 
 	"github.com/gofrs/uuid/v5"
@@ -122,6 +124,8 @@ func TestInitKibanaConfig(t *testing.T) {
 
 func TestEmptyMetaJson(t *testing.T) {
 	b, err := NewBeat("filebeat", "testidx", "0.9", false, nil)
+	logger := logptest.NewTestingLogger(t, "")
+	b.Info.Logger = logger
 	if err != nil {
 		panic(err)
 	}
@@ -143,7 +147,8 @@ func TestEmptyMetaJson(t *testing.T) {
 
 func TestMetaJsonWithTimestamp(t *testing.T) {
 	firstBeat, err := NewBeat("filebeat", "testidx", "0.9", false, nil)
-
+	logger := logptest.NewTestingLogger(t, "")
+	firstBeat.Info.Logger = logger
 	if err != nil {
 		panic(err)
 	}
@@ -163,6 +168,7 @@ func TestMetaJsonWithTimestamp(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
+	secondBeat.Info.Logger = logger
 	assert.False(t, firstStart.Equal(secondBeat.Info.FirstStart), "Before meta.json is loaded, first start must be different")
 	err = secondBeat.LoadMeta(metaPath)
 	require.NoError(t, err)
@@ -329,11 +335,20 @@ output:
 
 			config := beatConfig{}
 			err = cfg.Unpack(&config)
+			require.NoError(t, err)
+
+			logger := logptest.NewTestingLogger(t, "")
+
+			b := &Beat{Config: config, Beat: beat.Beat{
+				Info: beat.Info{
+					Logger: logger,
+				},
+			}}
 
-			err = PromoteOutputQueueSettings(&config)
+			err = PromoteOutputQueueSettings(b)
 			require.NoError(t, err)
 
-			ms, err := memqueue.SettingsForUserConfig(config.Pipeline.Queue.Config())
+			ms, err := memqueue.SettingsForUserConfig(b.Config.Pipeline.Queue.Config())
 			require.NoError(t, err)
 			require.Equalf(t, tc.memEvents, ms.Events, "config was: %v", config.Pipeline.Queue.Config())
 		})
@@ -463,13 +478,14 @@ func TestLogSystemInfo(t *testing.T) {
 	log.WithOptions()
 
 	b, err := NewBeat("testingbeat", "test-idx", "42", false, nil)
+	b.Info.Logger = log
 	require.NoError(t, err, "could not create beat")
 
 	for _, tc := range tcs {
 		buff.Reset()
 
 		b.Manager = mockManager{enabled: tc.managed}
-		b.logSystemInfo(log)
+		b.logSystemInfo()
 
 		tc.assertFn(t, buff)
 	}
diff --git a/libbeat/cmd/instance/locks/lock.go b/libbeat/cmd/instance/locks/lock.go
index c520b6e95434..529d0cece0f6 100644
--- a/libbeat/cmd/instance/locks/lock.go
+++ b/libbeat/cmd/instance/locks/lock.go
@@ -55,7 +55,7 @@ func NewWithRetry(beatInfo beat.Info, retryCount int, retrySleep time.Duration)
 		fileLock:   flock.New(lockfilePath),
 		retryCount: retryCount,
 		retrySleep: retrySleep,
-		logger:     logp.L(),
+		logger:     beatInfo.Logger,
 	}
 }
 
diff --git a/libbeat/cmd/instance/locks/lock_test.go b/libbeat/cmd/instance/locks/lock_test.go
index 6e20f1263903..f2d5d77d2a8d 100644
--- a/libbeat/cmd/instance/locks/lock_test.go
+++ b/libbeat/cmd/instance/locks/lock_test.go
@@ -25,12 +25,11 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/elastic/beats/v7/libbeat/beat"
-	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/paths"
 )
 
 func TestMain(m *testing.M) {
-	logp.DevelopmentSetup()
 
 	tmp, err := os.MkdirTemp("", "pidfile_test")
 	defer os.RemoveAll(tmp)
@@ -59,10 +58,12 @@ func TestLocker(t *testing.T) {
 	// Setup two beats with same name and data path
 	const beatName = "testbeat-testlocker"
 
-	b1 := beat.Info{}
+	logger := logptest.NewTestingLogger(t, "")
+
+	b1 := beat.Info{Logger: logger}
 	b1.Beat = beatName
 
-	b2 := beat.Info{}
+	b2 := beat.Info{Logger: logger}
 	b2.Beat = beatName
 
 	// Try to get a lock for the first beat. Expect it to succeed.
@@ -80,8 +81,9 @@ func TestLocker(t *testing.T) {
 
 func TestUnlock(t *testing.T) {
 	const beatName = "testbeat-testunlock"
+	logger := logptest.NewTestingLogger(t, "")
 
-	b1 := beat.Info{}
+	b1 := beat.Info{Logger: logger}
 	b1.Beat = beatName
 
 	b2 := beat.Info{}
@@ -105,8 +107,9 @@ func TestUnlock(t *testing.T) {
 
 func TestUnlockWithRemainingFile(t *testing.T) {
 	const beatName = "testbeat-testunlockwithfile"
+	logger := logptest.NewTestingLogger(t, "")
 
-	b1 := beat.Info{}
+	b1 := beat.Info{Logger: logger}
 	b1.Beat = beatName
 
 	b2 := beat.Info{}
diff --git a/libbeat/cmd/test/output.go b/libbeat/cmd/test/output.go
index 3290c283c27f..fdbfbcee4bee 100644
--- a/libbeat/cmd/test/output.go
+++ b/libbeat/cmd/test/output.go
@@ -40,7 +40,7 @@ func GenTestOutputCmd(settings instance.Settings) *cobra.Command {
 				os.Exit(1)
 			}
 
-			im, _ := idxmgmt.DefaultSupport(nil, b.Info, nil)
+			im, _ := idxmgmt.DefaultSupport(b.Info.Logger, b.Info, nil)
 			output, err := outputs.Load(im, b.Info, nil, b.Config.Output.Name(), b.Config.Output.Config())
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error initializing output: %s\n", err)
diff --git a/libbeat/idxmgmt/idxmgmt.go b/libbeat/idxmgmt/idxmgmt.go
index 4cd3fbe93e34..fa5a547dd3b5 100644
--- a/libbeat/idxmgmt/idxmgmt.go
+++ b/libbeat/idxmgmt/idxmgmt.go
@@ -93,24 +93,20 @@ func (m *LoadMode) Enabled() bool {
 
 // DefaultSupport initializes the default index management support used by most Beats.
 func DefaultSupport(log *logp.Logger, info beat.Info, configRoot *config.C) (Supporter, error) {
-	factory := MakeDefaultSupport(nil)
+	factory := MakeDefaultSupport(nil, log)
 	return factory(log, info, configRoot)
 }
 
 // MakeDefaultSupport creates some default index management support, with a
 // custom ILM support implementation.
-func MakeDefaultSupport(ilmSupport lifecycle.SupportFactory) SupportFactory {
+func MakeDefaultSupport(ilmSupport lifecycle.SupportFactory, logger *logp.Logger) SupportFactory {
 	if ilmSupport == nil {
 		ilmSupport = lifecycle.DefaultSupport
 	}
 
 	return func(log *logp.Logger, info beat.Info, configRoot *config.C) (Supporter, error) {
 		const logName = "index-management"
-		if log == nil {
-			log = logp.NewLogger(logName)
-		} else {
-			log = log.Named(logName)
-		}
+		log = log.Named(logName)
 
 		// now that we have the "correct" default, unpack the rest of the config
 		cfg := struct {
diff --git a/libbeat/idxmgmt/std_test.go b/libbeat/idxmgmt/std_test.go
index 4a5dd0f7d33c..970fa51cda35 100644
--- a/libbeat/idxmgmt/std_test.go
+++ b/libbeat/idxmgmt/std_test.go
@@ -32,6 +32,7 @@ import (
 	"github.com/elastic/beats/v7/libbeat/mapping"
 	"github.com/elastic/beats/v7/libbeat/template"
 	"github.com/elastic/elastic-agent-libs/config"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
 
@@ -76,11 +77,13 @@ func TestDefaultSupport_Enabled(t *testing.T) {
 			},
 		},
 	}
+
 	for name, test := range cases {
 		t.Run(name, func(t *testing.T) {
+			logger := logptest.NewTestingLogger(t, "")
 			info := beat.Info{Beat: "test", Version: "9.9.9"}
-			factory := MakeDefaultSupport(makeMockILMSupport(test.ilmCalls...))
-			im, err := factory(nil, info, config.MustNewConfigFrom(test.cfg))
+			factory := MakeDefaultSupport(makeMockILMSupport(test.ilmCalls...), logger)
+			im, err := factory(logger, info, config.MustNewConfigFrom(test.cfg))
 			require.NoError(t, err)
 			assert.Equal(t, test.enabled, im.Enabled())
 		})
@@ -176,11 +179,13 @@ func TestDefaultSupport_BuildSelector(t *testing.T) {
 	}
 	for name, test := range cases {
 		t.Run(name, func(t *testing.T) {
+			logger := logptest.NewTestingLogger(t, "")
+
 			ts := time.Now()
 			info := beat.Info{Beat: "test", Version: "9.9.9"}
 
-			factory := MakeDefaultSupport(makeMockILMSupport(test.ilmCalls...))
-			im, err := factory(nil, info, config.MustNewConfigFrom(test.imCfg))
+			factory := MakeDefaultSupport(makeMockILMSupport(test.ilmCalls...), logger)
+			im, err := factory(logger, info, config.MustNewConfigFrom(test.imCfg))
 			require.NoError(t, err)
 
 			sel, err := im.BuildSelector(config.MustNewConfigFrom(test.cfg))
@@ -256,13 +261,14 @@ func TestIndexManager_VerifySetup(t *testing.T) {
 		},
 	} {
 		t.Run(name, func(t *testing.T) {
+			logger := logptest.NewTestingLogger(t, "")
 			cfg, err := config.NewConfigFrom(mapstr.M{
 				"setup.ilm.enabled":      setup.ilmEnabled,
 				"setup.ilm.overwrite":    setup.ilmOverwrite,
 				"setup.template.enabled": setup.tmplEnabled,
 			})
 			require.NoError(t, err)
-			support, err := MakeDefaultSupport(lifecycle.StdSupport)(nil, beat.Info{}, cfg)
+			support, err := MakeDefaultSupport(lifecycle.StdSupport, logger)(logger, beat.Info{}, cfg)
 			require.NoError(t, err)
 			clientHandler, err := newMockClientHandler(setup.lifecycle, info)
 			require.NoError(t, err)
@@ -441,8 +447,9 @@ func TestIndexManager_Setup(t *testing.T) {
 	}
 	for name, test := range cases {
 		t.Run(name, func(t *testing.T) {
-			factory := MakeDefaultSupport(lifecycle.StdSupport)
-			im, err := factory(nil, info, config.MustNewConfigFrom(test.cfg))
+			logger := logptest.NewTestingLogger(t, "")
+			factory := MakeDefaultSupport(lifecycle.StdSupport, logger)
+			im, err := factory(logger, info, config.MustNewConfigFrom(test.cfg))
 			require.NoError(t, err)
 
 			clientHandler, err := newMockClientHandler(test.ilmCfg, info)
diff --git a/libbeat/instrumentation/instrumentation.go b/libbeat/instrumentation/instrumentation.go
index 3c3515f0b5ad..a9413b3cbbe6 100644
--- a/libbeat/instrumentation/instrumentation.go
+++ b/libbeat/instrumentation/instrumentation.go
@@ -134,7 +134,7 @@ type HeapProfiling struct {
 }
 
 // New configures and returns an instrumentation object for tracing
-func New(cfg *config.C, beatName, beatVersion string) (Instrumentation, error) {
+func New(cfg *config.C, beatName, beatVersion string, logger *logp.Logger) (Instrumentation, error) {
 	if !cfg.HasField("instrumentation") {
 		return &instrumentation{}, nil
 	}
@@ -155,12 +155,12 @@ func New(cfg *config.C, beatName, beatVersion string) (Instrumentation, error) {
 		return nil, fmt.Errorf("could not create tracer, err: %v", err)
 	}
 
-	return initTracer(c, beatName, beatVersion)
+	return initTracer(c, beatName, beatVersion, logger)
 }
 
-func initTracer(cfg Config, beatName, beatVersion string) (*instrumentation, error) {
+func initTracer(cfg Config, beatName, beatVersion string, logger *logp.Logger) (*instrumentation, error) {
 
-	logger := logp.NewLogger("tracing")
+	logger = logger.Named("tracing")
 
 	if !cfg.IsEnabled() {
 		os.Setenv("ELASTIC_APM_ACTIVE", "false")
diff --git a/libbeat/instrumentation/instrumentation_test.go b/libbeat/instrumentation/instrumentation_test.go
index 0b9533ff4754..3d8c2240d279 100644
--- a/libbeat/instrumentation/instrumentation_test.go
+++ b/libbeat/instrumentation/instrumentation_test.go
@@ -25,6 +25,7 @@ import (
 
 	"github.com/elastic/beats/v7/libbeat/version"
 	"github.com/elastic/elastic-agent-libs/config"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 )
 
 func TestInstrumentationConfig(t *testing.T) {
@@ -33,7 +34,8 @@ func TestInstrumentationConfig(t *testing.T) {
 			"enabled": "true",
 		},
 	})
-	instrumentation, err := New(cfg, "my-beat", version.GetDefaultVersion())
+	logger := logptest.NewTestingLogger(t, "")
+	instrumentation, err := New(cfg, "my-beat", version.GetDefaultVersion(), logger)
 	require.NoError(t, err)
 
 	tracer := instrumentation.Tracer()
@@ -50,7 +52,8 @@ func TestInstrumentationConfigExplicitHosts(t *testing.T) {
 		},
 	},
 	)
-	instrumentation, err := New(cfg, "my-beat", version.GetDefaultVersion())
+	logger := logptest.NewTestingLogger(t, "")
+	instrumentation, err := New(cfg, "my-beat", version.GetDefaultVersion(), logger)
 	require.NoError(t, err)
 	tracer := instrumentation.Tracer()
 	defer tracer.Close()
@@ -64,7 +67,9 @@ func TestInstrumentationConfigListener(t *testing.T) {
 			"enabled": "true",
 		},
 	})
-	instrumentation, err := New(cfg, "apm-server", version.GetDefaultVersion())
+	logger := logptest.NewTestingLogger(t, "")
+
+	instrumentation, err := New(cfg, "apm-server", version.GetDefaultVersion(), logger)
 	require.NoError(t, err)
 
 	tracer := instrumentation.Tracer()
@@ -74,7 +79,9 @@ func TestInstrumentationConfigListener(t *testing.T) {
 }
 
 func TestAPMTracerDisabledByDefault(t *testing.T) {
-	instrumentation, err := New(config.NewConfig(), "beat", "8.0")
+	logger := logptest.NewTestingLogger(t, "")
+
+	instrumentation, err := New(config.NewConfig(), "beat", "8.0", logger)
 	require.NoError(t, err)
 	tracer := instrumentation.Tracer()
 	require.NotNil(t, tracer)
@@ -87,7 +94,9 @@ func TestInstrumentationDisabled(t *testing.T) {
 			"enabled": "false",
 		},
 	})
-	instrumentation, err := New(cfg, "filebeat", version.GetDefaultVersion())
+	logger := logptest.NewTestingLogger(t, "")
+
+	instrumentation, err := New(cfg, "filebeat", version.GetDefaultVersion(), logger)
 	require.NoError(t, err)
 	require.NotNil(t, instrumentation)
 
diff --git a/libbeat/monitoring/report/elasticsearch/client.go b/libbeat/monitoring/report/elasticsearch/client.go
index 28be1c379172..8bf7b8ca6db6 100644
--- a/libbeat/monitoring/report/elasticsearch/client.go
+++ b/libbeat/monitoring/report/elasticsearch/client.go
@@ -49,12 +49,13 @@ type publishClient struct {
 func newPublishClient(
 	es *eslegclient.Connection,
 	params map[string]string,
+	logger *logp.Logger,
 ) (*publishClient, error) {
 	p := &publishClient{
 		es:     es,
 		params: params,
 
-		log: logp.NewLogger(logSelector),
+		log: logger.Named(logSelector),
 	}
 	return p, nil
 }
diff --git a/libbeat/monitoring/report/elasticsearch/elasticsearch.go b/libbeat/monitoring/report/elasticsearch/elasticsearch.go
index 5157d6018712..9ae49d7213a9 100644
--- a/libbeat/monitoring/report/elasticsearch/elasticsearch.go
+++ b/libbeat/monitoring/report/elasticsearch/elasticsearch.go
@@ -97,7 +97,7 @@ func defaultConfig(settings report.Settings) config {
 }
 
 func makeReporter(beat beat.Info, settings report.Settings, cfg *conf.C) (report.Reporter, error) {
-	log := logp.NewLogger(logSelector)
+	log := beat.Logger.Named(logSelector)
 	config := defaultConfig(settings)
 	if err := cfg.Unpack(&config); err != nil {
 		return nil, err
@@ -321,7 +321,7 @@ func makeClient(host string, params map[string]string, config *config, beat beat
 		return nil, err
 	}
 
-	return newPublishClient(esClient, params)
+	return newPublishClient(esClient, params, beat.Logger)
 }
 
 func closing(log *logp.Logger, c io.Closer) {
diff --git a/libbeat/monitoring/report/elasticsearch/elasticsearch_test.go b/libbeat/monitoring/report/elasticsearch/elasticsearch_test.go
index bc6b6e52d435..b9730a9ff150 100644
--- a/libbeat/monitoring/report/elasticsearch/elasticsearch_test.go
+++ b/libbeat/monitoring/report/elasticsearch/elasticsearch_test.go
@@ -25,6 +25,7 @@ import (
 	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/monitoring/report"
 	conf "github.com/elastic/elastic-agent-libs/config"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 )
 
 func TestMakeClientParams(t *testing.T) {
@@ -49,7 +50,9 @@ func TestMakeReporter(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	r, err := makeReporter(beat.Info{}, report.Settings{}, c)
+	logger := logptest.NewTestingLogger(t, "")
+
+	r, err := makeReporter(beat.Info{Logger: logger}, report.Settings{}, c)
 	require.NoError(t, err)
 	r.Stop()
 }
diff --git a/libbeat/monitoring/report/log/log.go b/libbeat/monitoring/report/log/log.go
index b40c6d33e42c..1e203bb30c03 100644
--- a/libbeat/monitoring/report/log/log.go
+++ b/libbeat/monitoring/report/log/log.go
@@ -118,7 +118,7 @@ func MakeReporter(beat beat.Info, cfg *conf.C) (report.Reporter, error) {
 	r := &reporter{
 		config:     config,
 		done:       make(chan struct{}),
-		logger:     logp.NewLogger("monitoring"),
+		logger:     beat.Logger.Named("monitoring"),
 		registries: map[string]*monitoring.Registry{},
 	}
 
diff --git a/libbeat/monitoring/report/log/log_test.go b/libbeat/monitoring/report/log/log_test.go
index 25086653ed5a..3063e9e068f6 100644
--- a/libbeat/monitoring/report/log/log_test.go
+++ b/libbeat/monitoring/report/log/log_test.go
@@ -21,10 +21,14 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
 
 	"github.com/elastic/beats/v7/libbeat/beat"
 	conf "github.com/elastic/elastic-agent-libs/config"
 	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/monitoring"
 )
@@ -58,7 +62,8 @@ var (
 
 // Smoke test.
 func TestStartStop(t *testing.T) {
-	r, err := MakeReporter(beat.Info{}, conf.NewConfig())
+	logger := logptest.NewTestingLogger(t, "")
+	r, err := MakeReporter(beat.Info{Logger: logger}, conf.NewConfig())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -77,11 +82,14 @@ func TestMakeDeltaSnapshot(t *testing.T) {
 }
 
 func TestReporterLog(t *testing.T) {
-	logp.DevelopmentSetup(logp.ToObserverOutput())
-	reporter := reporter{config: defaultConfig(), logger: logp.NewLogger("monitoring")}
+	observed, zapLogs := observer.New(zapcore.DebugLevel)
+	logger, err := logp.ConfigureWithCoreLocal(logp.Config{}, observed)
+	require.NoError(t, err)
+
+	reporter := reporter{config: defaultConfig(), logger: logger.Named("monitoring")}
 
 	reporter.logSnapshot(map[string]monitoring.FlatSnapshot{})
-	logs := logp.ObserverLogs().TakeAll()
+	logs := zapLogs.TakeAll()
 	if assert.Len(t, logs, 1) {
 		assert.Equal(t, "No non-zero metrics in the last 30s", logs[0].Message)
 	}
@@ -95,14 +103,14 @@ func TestReporterLog(t *testing.T) {
 			},
 		},
 	)
-	logs = logp.ObserverLogs().TakeAll()
+	logs = zapLogs.TakeAll()
 	if assert.Len(t, logs, 1) {
 		assert.Equal(t, "Non-zero metrics in the last 30s", logs[0].Message)
 		assertMapHas(t, logs[0].ContextMap(), "monitoring.metrics.running", true)
 	}
 
 	reporter.logTotals(map[string]monitoring.FlatSnapshot{"metrics": curSnap})
-	logs = logp.ObserverLogs().TakeAll()
+	logs = zapLogs.TakeAll()
 	if assert.Len(t, logs, 2) {
 		assert.Equal(t, "Total metrics", logs[0].Message)
 		assertMapHas(t, logs[0].ContextMap(), "monitoring.metrics.count", 20)
diff --git a/libbeat/outputs/elasticsearch/client_integration_test.go b/libbeat/outputs/elasticsearch/client_integration_test.go
index f4fb0e4f9a94..7903925c77b2 100644
--- a/libbeat/outputs/elasticsearch/client_integration_test.go
+++ b/libbeat/outputs/elasticsearch/client_integration_test.go
@@ -38,6 +38,7 @@ import (
 	"github.com/elastic/beats/v7/libbeat/outputs/outest"
 	conf "github.com/elastic/elastic-agent-libs/config"
 	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/monitoring"
 )
@@ -83,7 +84,7 @@ func testPublishEvent(t *testing.T, index string, cfg map[string]interface{}) {
 	// drop old index preparing test
 	_, _, _ = client.conn.Delete(index, "", "", nil)
 
-	batch := encodeBatch(client, outest.NewBatch(beat.Event{
+	batch := encodeBatch[*outest.Batch](client, outest.NewBatch(beat.Event{
 		Timestamp: time.Now(),
 		Fields: mapstr.M{
 			"type":    "libbeat",
@@ -135,7 +136,7 @@ func TestClientPublishEventWithPipeline(t *testing.T) {
 	}
 
 	publish := func(event beat.Event) {
-		batch := encodeBatch(client, outest.NewBatch(event))
+		batch := encodeBatch[*outest.Batch](client, outest.NewBatch(event))
 		err := output.Publish(context.Background(), batch)
 		if err != nil {
 			t.Fatal(err)
@@ -217,7 +218,7 @@ func TestClientBulkPublishEventsWithDeadletterIndex(t *testing.T) {
 	_, _, _ = client.conn.Delete(index, "", "", nil)
 	_, _, _ = client.conn.Delete(deadletterIndex, "", "", nil)
 
-	batch := encodeBatch(client, outest.NewBatch(beat.Event{
+	batch := encodeBatch[*outest.Batch](client, outest.NewBatch(beat.Event{
 		Timestamp: time.Now(),
 		Fields: mapstr.M{
 			"type":      "libbeat",
@@ -230,7 +231,7 @@ func TestClientBulkPublishEventsWithDeadletterIndex(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	batch = encodeBatch(client, outest.NewBatch(beat.Event{
+	batch = encodeBatch[*outest.Batch](client, outest.NewBatch(beat.Event{
 		Timestamp: time.Now(),
 		Fields: mapstr.M{
 			"type":      "libbeat",
@@ -279,7 +280,7 @@ func TestClientBulkPublishEventsWithPipeline(t *testing.T) {
 	}
 
 	publish := func(events ...beat.Event) {
-		batch := encodeBatch(client, outest.NewBatch(events...))
+		batch := encodeBatch[*outest.Batch](client, outest.NewBatch(events...))
 		err := output.Publish(context.Background(), batch)
 		if err != nil {
 			t.Fatal(err)
@@ -352,7 +353,7 @@ func TestClientPublishTracer(t *testing.T) {
 
 	_, _, _ = client.conn.Delete(index, "", "", nil)
 
-	batch := encodeBatch(client, outest.NewBatch(beat.Event{
+	batch := encodeBatch[*outest.Batch](client, outest.NewBatch(beat.Event{
 		Timestamp: time.Now(),
 		Fields: mapstr.M{
 			"message": "Hello world",
@@ -417,7 +418,8 @@ func connectTestEs(t *testing.T, cfg interface{}, stats outputs.Observer) (outpu
 
 	info := beat.Info{Beat: "libbeat"}
 	// disable ILM if using specified index name
-	im, _ := idxmgmt.DefaultSupport(nil, info, conf.MustNewConfigFrom(map[string]interface{}{"setup.ilm.enabled": "false"}))
+	logger := logptest.NewTestingLogger(t, "")
+	im, _ := idxmgmt.DefaultSupport(logger, info, conf.MustNewConfigFrom(map[string]interface{}{"setup.ilm.enabled": "false"}))
 	output, err := makeES(im, info, stats, config)
 	if err != nil {
 		t.Fatal(err)
diff --git a/libbeat/outputs/elasticsearch/client_test.go b/libbeat/outputs/elasticsearch/client_test.go
index f6322383cb5a..63d1c095f543 100644
--- a/libbeat/outputs/elasticsearch/client_test.go
+++ b/libbeat/outputs/elasticsearch/client_test.go
@@ -49,6 +49,7 @@ import (
 	"github.com/elastic/beats/v7/libbeat/version"
 	c "github.com/elastic/elastic-agent-libs/config"
 	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/monitoring"
 	libversion "github.com/elastic/elastic-agent-libs/version"
@@ -870,13 +871,14 @@ func TestBulkEncodeEvents(t *testing.T) {
 	for name, test := range cases {
 		test := test
 		t.Run(name, func(t *testing.T) {
+			logger := logptest.NewTestingLogger(t, "")
 			cfg := c.MustNewConfigFrom(test.config)
 			info := beat.Info{
 				IndexPrefix: "test",
 				Version:     test.version,
 			}
 
-			im, err := idxmgmt.DefaultSupport(nil, info, c.NewConfig())
+			im, err := idxmgmt.DefaultSupport(logger, info, c.NewConfig())
 			require.NoError(t, err)
 
 			index, pipeline, err := buildSelectors(im, info, cfg)
@@ -944,7 +946,8 @@ func TestBulkEncodeEventsWithOpType(t *testing.T) {
 		Version:     version.GetDefaultVersion(),
 	}
 
-	im, err := idxmgmt.DefaultSupport(nil, info, c.NewConfig())
+	logger := logptest.NewTestingLogger(t, "")
+	im, err := idxmgmt.DefaultSupport(logger, info, c.NewConfig())
 	require.NoError(t, err)
 
 	index, pipeline, err := buildSelectors(im, info, cfg)
diff --git a/libbeat/outputs/logstash/logstash_integration_test.go b/libbeat/outputs/logstash/logstash_integration_test.go
index 286717e49ede..f368a43a9a6d 100644
--- a/libbeat/outputs/logstash/logstash_integration_test.go
+++ b/libbeat/outputs/logstash/logstash_integration_test.go
@@ -41,6 +41,7 @@ import (
 	"github.com/elastic/beats/v7/libbeat/publisher"
 	"github.com/elastic/beats/v7/libbeat/publisher/queue"
 	conf "github.com/elastic/elastic-agent-libs/config"
+	"github.com/elastic/elastic-agent-libs/logp/logptest"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/transport/httpcommon"
 )
@@ -191,8 +192,9 @@ func newTestElasticsearchOutput(t *testing.T, test string) *testOutputer {
 		"template.enabled": false,
 	})
 
+	logger := logptest.NewTestingLogger(t, "")
 	info := beat.Info{Beat: "libbeat"}
-	im, err := idxmgmt.DefaultSupport(nil, info, conf.MustNewConfigFrom(
+	im, err := idxmgmt.DefaultSupport(logger, info, conf.MustNewConfigFrom(
 		map[string]interface{}{
 			"setup.ilm.enabled": false,
 		},
@@ -565,13 +567,13 @@ func checkEvent(t *testing.T, ls, es map[string]interface{}) {
 }
 
 func (t *testOutputer) PublishEvent(event beat.Event) {
-	batch := encodeBatch(t.encoder, outest.NewBatch(event))
+	batch := encodeBatch[*outest.Batch](t.encoder, outest.NewBatch(event))
 	t.Publish(context.Background(), batch)
 }
 
 func (t *testOutputer) BulkPublish(events []beat.Event) bool {
 	ok := false
-	batch := encodeBatch(t.encoder, outest.NewBatch(events...))
+	batch := encodeBatch[*outest.Batch](t.encoder, outest.NewBatch(events...))
 
 	var wg sync.WaitGroup
 	wg.Add(1)
diff --git a/x-pack/libbeat/cmd/instance/beat.go b/x-pack/libbeat/cmd/instance/beat.go
index 190f245e03fe..4b71a01be1b5 100644
--- a/x-pack/libbeat/cmd/instance/beat.go
+++ b/x-pack/libbeat/cmd/instance/beat.go
@@ -121,18 +121,21 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 		return nil, fmt.Errorf("error unpacking beats logging config: %w\n%v", err, b.Config.Logging)
 	}
 
-	err = logp.ConfigureWithCore(logpConfig, core)
+	b.Info.Logger, err = logp.ConfigureWithCoreLocal(logpConfig, core)
 	if err != nil {
 		return nil, fmt.Errorf("error configuring beats logp: %w", err)
 	}
 
-	instrumentation, err := instrumentation.New(cfg, b.Info.Beat, b.Info.Version)
+	// extracting it here for ease of use
+	logger := b.Info.Logger
+
+	instrumentation, err := instrumentation.New(cfg, b.Info.Beat, b.Info.Version, logger)
 	if err != nil {
 		return nil, fmt.Errorf("error setting up instrumentation: %w", err)
 	}
 	b.Instrumentation = instrumentation
 
-	if err := instance.PromoteOutputQueueSettings(&b.Config); err != nil {
+	if err := instance.PromoteOutputQueueSettings(b); err != nil {
 		return nil, fmt.Errorf("could not promote output queue settings: %w", err)
 	}
 
@@ -152,7 +155,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 	}
 
 	// log paths values to help with troubleshooting
-	logp.Info("%s", paths.Paths.String())
+	logger.Infof("%s", paths.Paths.String())
 
 	metaPath := paths.Resolve(paths.Data, "meta.json")
 	err = b.LoadMeta(metaPath)
@@ -160,7 +163,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 		return nil, fmt.Errorf("error loading meta data: %w", err)
 	}
 
-	logp.Info("Beat ID: %v", b.Info.ID)
+	logger.Infof("Beat ID: %v", b.Info.ID)
 
 	// Try to get the host's FQDN and set it.
 	h, err := sysinfo.Host()
@@ -175,7 +178,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 	if err != nil {
 		// FQDN lookup is "best effort".  We log the error, fallback to
 		// the OS-reported hostname, and move on.
-		logp.Warn("unable to lookup FQDN: %s, using hostname = %s as FQDN", err.Error(), b.Info.Hostname)
+		logger.Warnf("unable to lookup FQDN: %s, using hostname = %s as FQDN", err.Error(), b.Info.Hostname)
 		b.Info.FQDN = b.Info.Hostname
 	} else {
 		b.Info.FQDN = fqdn
@@ -216,9 +219,9 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 
 	imFactory := settings.IndexManagement
 	if imFactory == nil {
-		imFactory = idxmgmt.MakeDefaultSupport(settings.ILM)
+		imFactory = idxmgmt.MakeDefaultSupport(settings.ILM, logger)
 	}
-	b.IdxSupporter, err = imFactory(nil, b.Info, b.RawConfig)
+	b.IdxSupporter, err = imFactory(logger, b.Info, b.RawConfig)
 	if err != nil {
 		return nil, fmt.Errorf("error setting index supporter: %w", err)
 	}
@@ -229,7 +232,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 		processingFactory = processing.MakeDefaultBeatSupport(true)
 	}
 
-	processors, err := processingFactory(b.Info, logp.L().Named("processors"), b.RawConfig)
+	processors, err := processingFactory(b.Info, logger.Named("processors"), b.RawConfig)
 	if err != nil {
 		return nil, fmt.Errorf("error creating processors: %w", err)
 	}
@@ -240,7 +243,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 	outputEnabled := b.Config.Output.IsSet() && b.Config.Output.Config().Enabled()
 	if !outputEnabled {
 		if b.Manager.Enabled() {
-			logp.Info("Output is configured through Central Management")
+			logger.Info("Output is configured through Central Management")
 		} else {
 			return nil, fmt.Errorf("no outputs are defined, please define one under the output section")
 		}
@@ -254,7 +257,7 @@ func NewBeatForReceiver(settings instance.Settings, receiverConfig map[string]an
 	monitors := pipeline.Monitors{
 		Metrics:   reg,
 		Telemetry: b.Info.Monitoring.StateRegistry,
-		Logger:    logp.L().Named("publisher"),
+		Logger:    logger.Named("publisher"),
 		Tracer:    b.Instrumentation.Tracer(),
 	}