Final slog migration PR: test infrastructure + tools + remaining standalone files (#40727)

<!-- Add the related story/sub-task/bug number, like Resolves #123, or
remove if NA -->
**Related issue:** Resolves #40540 

go-kit/log is no longer a direct dependency; moved kitlog adapter
required for some 3rd party libraries into its own package

# Checklist for submitter

- [ ] Changes file added for user-visible changes in `changes/`,
`orbit/changes/` or `ee/fleetd-chrome/changes`.
  - Present in previous PR

## Testing

- [x] Added/updated automated tests
- [x] QA'd all new/changed functionality manually

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Chores**
* Modernized logging across the codebase: switched from legacy logging
wrappers to Go's standard slog, updated adapters, tests, tools, and
server components.
* Threaded the new slog logger through test utilities and tooling;
adjusted a small number of logging-related function/constructor
signatures to accept the new logger type (minor compatibility updates).
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

cmd/fleetctl/fleetctl/preview.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"os"
 	"os/exec"
@@ -27,7 +28,6 @@ import (
 	"github.com/fleetdm/fleet/v4/pkg/open"
 	"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/google/go-github/v37/github"
 	"github.com/mitchellh/go-ps"
@@ -373,16 +373,16 @@ Use the stop and reset subcommands to manage the server and dependencies once st
 
 			fmt.Println("Loading starter library...")
 
-			logger := logging.NewNopLogger()
+			logger := slog.New(slog.DiscardHandler)
 			if c.Bool(debugFlagName) {
-				logger = logging.NewLogfmtLogger(os.Stderr)
+				logger = slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
 			}
 
 			if err := service.ApplyStarterLibrary(
 				c.Context,
 				address,
 				token,
-				logger.SlogLogger(),
+				logger,
 				fleethttp.NewClient,
 				service.NewClient,
 				nil, // No mock ApplyGroup for production code

cmd/fleetctl/fleetctl/query_test.go

@@ -2,6 +2,7 @@ package fleetctl
 
 import (
 	"context"
+	"log/slog"
 	"os"
 	"sync"
 	"testing"
@@ -10,7 +11,6 @@ import (
 	"github.com/fleetdm/fleet/v4/cmd/fleetctl/fleetctl/testing_utils"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/live_query/live_query_mock"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/pubsub"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/stretchr/testify/assert"
@@ -21,7 +21,7 @@ func TestSavedLiveQuery(t *testing.T) {
 	rs := pubsub.NewInmemQueryResults()
 	lq := live_query_mock.New(t)
 
-	logger := logging.NewJSONLogger(os.Stdout)
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
 	_, ds := testing_utils.RunServerWithMockedDS(t, &service.TestServerOpts{
 		Rs:     rs,
@@ -194,7 +194,7 @@ func TestAdHocLiveQuery(t *testing.T) {
 	rs := pubsub.NewInmemQueryResults()
 	lq := live_query_mock.New(t)
 
-	logger := logging.NewJSONLogger(os.Stdout)
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
 	_, ds := testing_utils.RunServerWithMockedDS(
 		t, &service.TestServerOpts{

cmd/fleetctl/fleetctl/trigger_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"strings"
 	"testing"
@@ -11,7 +12,6 @@ import (
 
 	"github.com/fleetdm/fleet/v4/cmd/fleetctl/fleetctl/testing_utils"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/service/schedule"
 	"github.com/stretchr/testify/assert"
@@ -54,7 +54,7 @@ func TestTrigger(t *testing.T) {
 	os.Stdout = w
 
 	_, _ = testing_utils.RunServerWithMockedDS(t, &service.TestServerOpts{
-		Logger: logging.NewNopLogger(),
+		Logger: slog.New(slog.DiscardHandler),
 		StartCronSchedules: []service.TestNewScheduleFunc{
 			func(ctx context.Context, ds fleet.Datastore) fleet.NewCronScheduleFunc {
 				return func() (fleet.CronSchedule, error) {

cmd/fleetctl/integrationtest/gitops/gitops_enterprise_integration_test.go

@@ -121,7 +121,7 @@ func (s *enterpriseIntegrationGitopsTestSuite) SetupSuite() {
 	require.NoError(s.T(), err)
 
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		serverConfig.Logger = logging.NewNopLogger()
+		serverConfig.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := service.RunServerForTestsWithDS(s.T(), s.DS, &serverConfig)
 	s.T().Setenv("FLEET_SERVER_ADDRESS", server.URL) // fleetctl always uses this env var in tests

ee/orbit/pkg/scep/scep.go

@@ -15,7 +15,7 @@ import (
 	"time"
 
 	scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/rs/zerolog"
 	"github.com/smallstep/scep"
@@ -151,7 +151,7 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
 	// We assume the required fields have already been validated by the NewClient factory.
 
 	slogLogger := slog.New(&zerologSlogHandler{logger: c.logger})
-	scepLogger := logging.NewLogger(slogLogger)
+	scepLogger := kitlogadapter.NewLogger(slogLogger)
 	opts := []scepclient.Option{
 		scepclient.WithTimeout(c.timeout),
 		scepclient.WithRootCA(c.rootCA),
@@ -283,7 +283,7 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
 	return pkiMsgResp.CertRepMessage.Certificate, nil
 }
 
-// zerologSlogHandler adapts zerolog.Logger to slog.Handler so it can be used with *logging.Logger.
+// zerologSlogHandler adapts zerolog.Logger to slog.Handler so it can be used with *slog.Logger.
 type zerologSlogHandler struct {
 	logger zerolog.Logger
 	attrs  []slog.Attr

ee/orbit/pkg/scep/scep_test.go

@@ -9,6 +9,7 @@ import (
 	"crypto/x509"
 	_ "embed"
 	"io"
+	"log/slog"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
@@ -18,7 +19,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
 	filedepot "github.com/fleetdm/fleet/v4/server/mdm/scep/depot/file"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/gorilla/mux"
 	"github.com/rs/zerolog"
@@ -209,9 +209,9 @@ func StartTestSCEPServer(t *testing.T) *httptest.Server {
 		if err != nil {
 			t.Fatal(err)
 		}
-		logger := logging.NewNopLogger()
+		logger := slog.New(slog.DiscardHandler)
 		e := scepserver.MakeServerEndpoints(svc)
-		scepHandler := scepserver.MakeHTTPHandler(e, svc, logger.SlogLogger())
+		scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
 		r := mux.NewRouter()
 		r.Handle("/scep", scepHandler)
 		server = httptest.NewServer(r)

ee/server/integrationtest/condaccess/condaccess_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/x509util"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/smallstep/scep"
@@ -270,7 +271,7 @@ func requestSCEPCertificateWithOptions(t *testing.T, s *Suite, uris []*url.URL,
 
 	// Create SCEP client
 	scepURL := fmt.Sprintf("%s/api/fleet/conditional_access/scep", s.Server.URL)
-	scepClient, err := scepclient.New(scepURL, s.Logger.SlogLogger())
+	scepClient, err := scepclient.New(scepURL, s.Logger)
 	require.NoError(t, err)
 
 	// Get CA certificate
@@ -308,7 +309,7 @@ func requestSCEPCertificateWithOptions(t *testing.T, s *Suite, uris []*url.URL,
 		SignerCert:  deviceCert,
 	}
 
-	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(s.Logger))
+	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)))
 	require.NoError(t, err)
 
 	// Send PKI operation request using HTTP client directly to capture response
@@ -333,7 +334,7 @@ func requestSCEPCertificateWithOptions(t *testing.T, s *Suite, uris []*url.URL,
 	require.NoError(t, err)
 
 	// Parse response
-	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(s.Logger), scep.WithCACerts(msg.Recipients))
+	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)), scep.WithCACerts(msg.Recipients))
 	require.NoError(t, err)
 
 	// Check for SCEP-level failure

ee/server/integrationtest/condaccess/suite.go

@@ -1,13 +1,13 @@
 package condaccess
 
 import (
+	"log/slog"
 	"os"
 	"testing"
 
 	"github.com/fleetdm/fleet/v4/server/config"
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/service/integrationtest"
 	"github.com/stretchr/testify/require"
@@ -36,14 +36,14 @@ func SetUpSuiteWithConfig(t *testing.T, uniqueTestName string, configModifier fu
 		configModifier(&fleetCfg)
 	}
 
-	logger := logging.NewLogfmtLogger(os.Stdout)
-	condAccessSCEPDepot, err := ds.NewConditionalAccessSCEPDepot(logger.SlogLogger().With("component", "conditional-access-scep-depot"), &fleetCfg)
+	slogLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
+	condAccessSCEPDepot, err := ds.NewConditionalAccessSCEPDepot(slogLogger.With("component", "conditional-access-scep-depot"), &fleetCfg)
 	require.NoError(t, err)
 
 	users, server := service.RunServerForTestsWithServiceWithDS(t, ctx, ds, fleetSvc, &service.TestServerOpts{
 		License:     license,
 		FleetConfig: &fleetCfg,
-		Logger:      logger,
+		Logger:      slogLogger,
 		ConditionalAccess: &service.ConditionalAccess{
 			SCEPStorage: condAccessSCEPDepot,
 		},
@@ -51,7 +51,7 @@ func SetUpSuiteWithConfig(t *testing.T, uniqueTestName string, configModifier fu
 
 	s := &Suite{
 		BaseSuite: integrationtest.BaseSuite{
-			Logger:   logger,
+			Logger:   slogLogger,
 			DS:       ds,
 			FleetCfg: fleetCfg,
 			Users:    users,

ee/server/integrationtest/hostidentity/hostidentity_test.go

@@ -37,6 +37,7 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/x509util"
 	"github.com/fleetdm/fleet/v4/server/service/contract"
 	"github.com/google/go-tpm/tpm2/transport/simulator"
@@ -124,7 +125,7 @@ func testGetCertWithCurve(t *testing.T, s *Suite, curve elliptic.Curve) (cert *x
 
 	// Create SCEP client
 	scepURL := fmt.Sprintf("%s/api/fleet/orbit/host_identity/scep", s.Server.URL)
-	scepClient, err := scepclient.New(scepURL, s.Logger.SlogLogger())
+	scepClient, err := scepclient.New(scepURL, s.Logger)
 	require.NoError(t, err)
 
 	// Get CA certificate
@@ -161,7 +162,7 @@ func testGetCertWithCurve(t *testing.T, s *Suite, curve elliptic.Curve) (cert *x
 		SignerCert:  deviceCert,
 	}
 
-	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(s.Logger))
+	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)))
 	require.NoError(t, err)
 
 	// Send PKI operation request
@@ -169,7 +170,7 @@ func testGetCertWithCurve(t *testing.T, s *Suite, curve elliptic.Curve) (cert *x
 	require.NoError(t, err)
 
 	// Parse response
-	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(s.Logger), scep.WithCACerts(msg.Recipients))
+	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)), scep.WithCACerts(msg.Recipients))
 	require.NoError(t, err)
 
 	// Verify successful response
@@ -595,7 +596,7 @@ func testCertificateRenewal(t *testing.T, s *Suite, existingCert *x509.Certifica
 
 	// Create SCEP client
 	scepURL := fmt.Sprintf("%s/api/fleet/orbit/host_identity/scep", s.Server.URL)
-	scepClient, err := scepclient.New(scepURL, s.Logger.SlogLogger())
+	scepClient, err := scepclient.New(scepURL, s.Logger)
 	require.NoError(t, err)
 
 	// Get CA certificate
@@ -616,7 +617,7 @@ func testCertificateRenewal(t *testing.T, s *Suite, existingCert *x509.Certifica
 		SignerCert:  tempRSACert,
 	}
 
-	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(s.Logger))
+	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)))
 	require.NoError(t, err)
 
 	// Send PKI operation request
@@ -624,7 +625,7 @@ func testCertificateRenewal(t *testing.T, s *Suite, existingCert *x509.Certifica
 	require.NoError(t, err)
 
 	// Parse response
-	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(s.Logger), scep.WithCACerts(msg.Recipients))
+	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)), scep.WithCACerts(msg.Recipients))
 	require.NoError(t, err)
 
 	// The renewal should succeed
@@ -769,7 +770,7 @@ func testCertificateRenewal(t *testing.T, s *Suite, existingCert *x509.Certifica
 			SignerCert:  retryTempRSACert,
 		}
 
-		retryMsg, err := scep.NewCSRRequest(retryCSR, retryPkiMsgReq, scep.WithLogger(s.Logger))
+		retryMsg, err := scep.NewCSRRequest(retryCSR, retryPkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)))
 		require.NoError(t, err)
 
 		// Send PKI operation request
@@ -777,7 +778,7 @@ func testCertificateRenewal(t *testing.T, s *Suite, existingCert *x509.Certifica
 		require.NoError(t, err)
 
 		// Parse response
-		retryPkiMsgResp, err := scep.ParsePKIMessage(retryRespBytes, scep.WithLogger(s.Logger), scep.WithCACerts(retryMsg.Recipients))
+		retryPkiMsgResp, err := scep.ParsePKIMessage(retryRespBytes, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)), scep.WithCACerts(retryMsg.Recipients))
 		require.NoError(t, err)
 
 		// Should fail - the certificate has already been revoked
@@ -963,7 +964,7 @@ func testSCEPFailure(t *testing.T, s *Suite, config SCEPFailureConfig) {
 
 	// Create SCEP client
 	scepURL := fmt.Sprintf("%s/api/fleet/orbit/host_identity/scep", s.Server.URL)
-	scepClient, err := scepclient.New(scepURL, s.Logger.SlogLogger())
+	scepClient, err := scepclient.New(scepURL, s.Logger)
 	require.NoError(t, err)
 
 	// Get CA certificate
@@ -1016,7 +1017,7 @@ func testSCEPFailure(t *testing.T, s *Suite, config SCEPFailureConfig) {
 		SignerCert:  deviceCert,
 	}
 
-	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(s.Logger))
+	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)))
 	require.NoError(t, err)
 
 	// Send PKI operation request
@@ -1024,7 +1025,7 @@ func testSCEPFailure(t *testing.T, s *Suite, config SCEPFailureConfig) {
 	require.NoError(t, err)
 
 	// Parse response
-	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(s.Logger), scep.WithCACerts(msg.Recipients))
+	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(s.Logger)), scep.WithCACerts(msg.Recipients))
 	require.NoError(t, err)
 
 	// Verify failure response

ee/server/integrationtest/hostidentity/scep_rate_limit_test.go

@@ -102,7 +102,7 @@ func requestSCEPCertificate(t *testing.T, s *Suite, hostIdentifier string) (*htt
 	// Create SCEP client
 	scepURL := s.Server.URL + "/api/fleet/orbit/host_identity/scep"
 	timeout := 30 * time.Second
-	scepClient, err := scepclient.New(scepURL, s.Logger.SlogLogger(), scepclient.WithTimeout(&timeout))
+	scepClient, err := scepclient.New(scepURL, s.Logger, scepclient.WithTimeout(&timeout))
 	require.NoError(t, err)
 
 	// Get CA certificate

ee/server/integrationtest/hostidentity/suite.go

@@ -5,13 +5,13 @@
 package hostidentity
 
 import (
+	"log/slog"
 	"os"
 	"testing"
 
 	"github.com/fleetdm/fleet/v4/server/config"
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/service/integrationtest"
 	"github.com/stretchr/testify/require"
@@ -56,13 +56,13 @@ func SetUpSuiteWithConfig(t *testing.T, uniqueTestName string, requireSignature
 		configModifier(&fleetCfg)
 	}
 
-	logger := logging.NewLogfmtLogger(os.Stdout)
-	hostIdentitySCEPDepot, err := ds.NewHostIdentitySCEPDepot(logger.SlogLogger().With("component", "host-id-scep-depot"), &fleetCfg)
+	slogLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
+	hostIdentitySCEPDepot, err := ds.NewHostIdentitySCEPDepot(slogLogger.With("component", "host-id-scep-depot"), &fleetCfg)
 	require.NoError(t, err)
 	users, server := service.RunServerForTestsWithServiceWithDS(t, ctx, ds, fleetSvc, &service.TestServerOpts{
 		License:     license,
 		FleetConfig: &fleetCfg,
-		Logger:      logger,
+		Logger:      slogLogger,
 		HostIdentity: &service.HostIdentity{
 			SCEPStorage:                 hostIdentitySCEPDepot,
 			RequireHTTPMessageSignature: requireSignature,
@@ -71,7 +71,7 @@ func SetUpSuiteWithConfig(t *testing.T, uniqueTestName string, requireSignature
 
 	s := &Suite{
 		BaseSuite: integrationtest.BaseSuite{
-			Logger:   logger,
+			Logger:   slogLogger,
 			DS:       ds,
 			FleetCfg: fleetCfg,
 			Users:    users,

ee/server/integrationtest/scim/suite.go

@@ -1,11 +1,11 @@
 package scim
 
 import (
+	"log/slog"
 	"os"
 	"testing"
 
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/service/integrationtest"
 )
@@ -22,17 +22,17 @@ func SetUpSuite(t *testing.T, uniqueTestName string) *Suite {
 	ds, fleetCfg, fleetSvc, ctx := integrationtest.SetUpMySQLAndService(t, uniqueTestName, &service.TestServerOpts{
 		License: license,
 	})
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	slogLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	users, server := service.RunServerForTestsWithServiceWithDS(t, ctx, ds, fleetSvc, &service.TestServerOpts{
 		License:     license,
 		FleetConfig: &fleetCfg,
-		Logger:      logger,
+		Logger:      slogLogger,
 		EnableSCIM:  true,
 	})
 
 	s := &Suite{
 		BaseSuite: integrationtest.BaseSuite{
-			Logger:   logger,
+			Logger:   slogLogger,
 			DS:       ds,
 			FleetCfg: fleetCfg,
 			Users:    users,

ee/server/service/condaccess/scep.go

@@ -15,8 +15,8 @@ import (
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/mdm/assets"
 	scepdepot "github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service/middleware/otel"
 	"github.com/smallstep/scep"
 )
@@ -159,7 +159,7 @@ func (svc *service) PKIOperation(ctx context.Context, data []byte) ([]byte, erro
 	if len(data) == 0 {
 		return nil, &fleet.BadRequestError{Message: "missing data for PKIOperation"}
 	}
-	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(logging.NewLogger(svc.logger)))
+	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(kitlogadapter.NewLogger(svc.logger)))
 	if err != nil {
 		return nil, err
 	}

ee/server/service/hostidentity/scep.go

@@ -25,8 +25,8 @@ import (
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/mdm/assets"
 	scepdepot "github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service/middleware/otel"
 	"github.com/smallstep/scep"
 )
@@ -269,7 +269,7 @@ func (svc *service) PKIOperation(ctx context.Context, data []byte) ([]byte, erro
 	if len(data) == 0 {
 		return nil, &fleet.BadRequestError{Message: "missing data for PKIOperation"}
 	}
-	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(logging.NewLogger(svc.logger)))
+	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(kitlogadapter.NewLogger(svc.logger)))
 	if err != nil {
 		return nil, err
 	}

ee/server/service/mdm_external_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -24,7 +25,6 @@ import (
 	mdmtesting "github.com/fleetdm/fleet/v4/server/mdm/testing_utils"
 	"github.com/fleetdm/fleet/v4/server/mock"
 	nanodep_mock "github.com/fleetdm/fleet/v4/server/mock/nanodep"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/test"
@@ -39,7 +39,7 @@ func setupMockDatastorePremiumService(t testing.TB) (*mock.Store, *eeservice.Ser
 	lic := &fleet.LicenseInfo{Tier: fleet.TierPremium}
 	ctx := license.NewContext(context.Background(), lic)
 
-	logger := logging.NewNopLogger()
+	logger := slog.New(slog.DiscardHandler)
 	fleetConfig := config.FleetConfig{
 		MDM: config.MDMConfig{
 			AppleSCEPCertBytes: eeservice.TestCert,
@@ -78,7 +78,7 @@ func setupMockDatastorePremiumService(t testing.TB) (*mock.Store, *eeservice.Ser
 		ds,
 		nil,
 		nil,
-		logger.SlogLogger(),
+		logger,
 		nil,
 		fleetConfig,
 		nil,
@@ -110,7 +110,7 @@ func setupMockDatastorePremiumService(t testing.TB) (*mock.Store, *eeservice.Ser
 	svc, err := eeservice.NewService(
 		freeSvc,
 		ds,
-		logger.SlogLogger(),
+		logger,
 		fleetConfig,
 		nil,
 		clock.C,

ee/server/service/testing_utils.go

@@ -5,6 +5,7 @@ import (
 	_ "embed"
 	"encoding/binary"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -16,7 +17,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
 	filedepot "github.com/fleetdm/fleet/v4/server/mdm/scep/depot/file"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/gorilla/mux"
 	"github.com/stretchr/testify/require"
 )
@@ -59,9 +59,9 @@ func NewTestSCEPServer(t *testing.T) *httptest.Server {
 	if err != nil {
 		t.Fatal(err)
 	}
-	logger := logging.NewNopLogger()
+	logger := slog.New(slog.DiscardHandler)
 	e := scepserver.MakeServerEndpoints(svc)
-	scepHandler := scepserver.MakeHTTPHandler(e, svc, logger.SlogLogger())
+	scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
 	r := mux.NewRouter()
 	r.Handle("/scep", scepHandler)
 	server := httptest.NewServer(r)

go.mod

@@ -62,7 +62,6 @@ require (
 	github.com/go-ini/ini v1.67.0
 	github.com/go-json-experiment/json v0.0.0-20250517221953-25912455fbc8
 	github.com/go-kit/kit v0.12.0
-	github.com/go-kit/log v0.2.1
 	github.com/go-ole/go-ole v1.2.6
 	github.com/go-sql-driver/mysql v1.9.3
 	github.com/gocarina/gocsv v0.0.0-20220310154401-d4df709ca055
@@ -257,6 +256,7 @@ require (
 	github.com/garyburd/go-oauth v0.0.0-20180319155456-bca2e7f09a17 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.6.2 // indirect
+	github.com/go-kit/log v0.2.1 // indirect
 	github.com/go-logfmt/logfmt v0.5.1 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect

pkg/mdm/mdmtest/apple.go

@@ -13,6 +13,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"math/big"
 	mrand "math/rand"
 	"net/http"
@@ -29,9 +30,9 @@ import (
 	apple_mdm "github.com/fleetdm/fleet/v4/server/mdm/apple"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanomdm/mdm"
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/x509util"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	httptransport "github.com/go-kit/kit/transport/http"
 	"github.com/google/uuid"
 	"github.com/micromdm/plist"
@@ -681,11 +682,11 @@ func (c *TestAppleMDMClient) fetchEnrollmentProfile(path string, body []byte) (e
 func (c *TestAppleMDMClient) doSCEP(url, challenge string) (*x509.Certificate, *rsa.PrivateKey, error) {
 	ctx := context.Background()
 
-	var logger *logging.Logger
+	var logger *slog.Logger
 	if c.debug {
-		logger = logging.NewJSONLogger(os.Stdout)
+		logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	} else {
-		logger = logging.NewNopLogger()
+		logger = slog.New(slog.DiscardHandler)
 	}
 	client, err := newSCEPClient(url, logger)
 	if err != nil {
@@ -781,7 +782,7 @@ func (c *TestAppleMDMClient) doSCEP(url, challenge string) (*x509.Certificate, *
 			ChallengePassword: c.EnrollInfo.SCEPChallenge,
 		},
 	}
-	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(logger))
+	msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitlogadapter.NewLogger(logger)))
 	if err != nil {
 		return nil, nil, fmt.Errorf("create CSR request: %w", err)
 	}
@@ -789,7 +790,7 @@ func (c *TestAppleMDMClient) doSCEP(url, challenge string) (*x509.Certificate, *
 	if err != nil {
 		return nil, nil, fmt.Errorf("do CSR request: %w", err)
 	}
-	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(logger), scep.WithCACerts(msg.Recipients))
+	pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(logger)), scep.WithCACerts(msg.Recipients))
 	if err != nil {
 		return nil, nil, fmt.Errorf("parse PKIMessage response: %w", err)
 	}
@@ -1296,14 +1297,14 @@ type scepClient interface {
 
 func newSCEPClient(
 	serverURL string,
-	logger *logging.Logger,
+	logger *slog.Logger,
 ) (scepClient, error) {
 	endpoints, err := makeClientSCEPEndpoints(serverURL)
 	if err != nil {
 		return nil, err
 	}
-	endpoints.GetEndpoint = scepserver.EndpointLoggingMiddleware(logger.SlogLogger())(endpoints.GetEndpoint)
-	endpoints.PostEndpoint = scepserver.EndpointLoggingMiddleware(logger.SlogLogger())(endpoints.PostEndpoint)
+	endpoints.GetEndpoint = scepserver.EndpointLoggingMiddleware(logger)(endpoints.GetEndpoint)
+	endpoints.PostEndpoint = scepserver.EndpointLoggingMiddleware(logger)(endpoints.PostEndpoint)
 	return endpoints, nil
 }
 

server/fleet/mdm_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"regexp"
@@ -17,7 +18,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/nanodep/godep"
 	"github.com/fleetdm/fleet/v4/server/mock"
 	nanodep_mock "github.com/fleetdm/fleet/v4/server/mock/nanodep"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/stretchr/testify/require"
 )
 
@@ -67,7 +67,7 @@ func TestDEPClient(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	logger := logging.NewNopLogger()
+	logger := slog.New(slog.DiscardHandler)
 	ds := new(mock.Store)
 
 	appCfg := fleet.AppConfig{}
@@ -241,7 +241,7 @@ func TestDEPClient(t *testing.T) {
 			return &nanodep_client.Config{BaseURL: srv.URL}, nil
 		}
 
-		dep := apple_mdm.NewDEPClient(store, ds, logger.SlogLogger())
+		dep := apple_mdm.NewDEPClient(store, ds, logger)
 		orgName := c.orgName
 		if orgName == "" {
 			// simulate using a new token, not yet saved in the DB, so we pass the

server/launcher/server.go

@@ -6,13 +6,12 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/fleetdm/fleet/v4/server/fleet"
+	"github.com/fleetdm/fleet/v4/server/health"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	kithttp "github.com/go-kit/kit/transport/http"
 	launcher "github.com/kolide/launcher/pkg/service"
 	grpc "google.golang.org/grpc"
-
-	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/health"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 )
 
 // Handler extends the grpc.Server, providing Handler that allows us to serve
@@ -28,7 +27,7 @@ func New(
 	grpcServer *grpc.Server,
 	healthCheckers map[string]health.Checker,
 ) *Handler {
-	kitLogger := logging.NewLogger(logger)
+	kitLogger := kitlogadapter.NewLogger(logger)
 	var svc launcher.KolideService
 	{
 		svc = &launcherWrapper{

server/mdm/android/service/enterprises_test.go

@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 	"errors"
+	"log/slog"
 	"net/http"
 	"os"
 	"testing"
@@ -14,7 +15,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/android"
 	android_mock "github.com/fleetdm/fleet/v4/server/mdm/android/mock"
 	ds_mock "github.com/fleetdm/fleet/v4/server/mock"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/assert"
@@ -26,10 +26,10 @@ import (
 func TestEnterprisesAuth(t *testing.T) {
 	androidAPIClient := android_mock.Client{}
 	androidAPIClient.InitCommonMocks()
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	fleetDS := InitCommonDSMocks()
 	activityModule := &noopActivityModule{} // This test does not verify activity creation.
-	svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+	svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 	require.NoError(t, err)
 
 	testCases := []struct {
@@ -124,11 +124,11 @@ func TestEnterprisesAuth(t *testing.T) {
 func TestEnterpriseSignupMissingPrivateKey(t *testing.T) {
 	androidAPIClient := android_mock.Client{}
 	androidAPIClient.InitCommonMocks()
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	fleetDS := InitCommonDSMocks()
 	activityModule := &noopActivityModule{} // This test does not verify activity creation.
 
-	svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+	svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 	require.NoError(t, err)
 
 	user := &fleet.User{ID: 1, GlobalRole: ptr.String(fleet.RoleAdmin)}
@@ -239,7 +239,7 @@ func (n *noopActivityModule) NewActivity(_ context.Context, _ *fleet.User, _ fle
 }
 
 func TestGetEnterprise(t *testing.T) {
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	user := &fleet.User{ID: 1, GlobalRole: ptr.String(fleet.RoleAdmin)}
 	ctx := viewer.NewContext(context.Background(), viewer.Viewer{User: user})
 
@@ -249,7 +249,7 @@ func TestGetEnterprise(t *testing.T) {
 
 		fleetDS := InitCommonDSMocks()
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		enterprise, err := svc.GetEnterprise(ctx)
@@ -269,7 +269,7 @@ func TestGetEnterprise(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		enterprise, err := svc.GetEnterprise(ctx)
@@ -283,7 +283,7 @@ func TestGetEnterprise(t *testing.T) {
 }
 
 func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	user := &fleet.User{ID: 1, GlobalRole: ptr.String(fleet.RoleAdmin)}
 	ctx := viewer.NewContext(context.Background(), viewer.Viewer{User: user})
 
@@ -315,7 +315,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		err = svc.VerifyExistingEnterpriseIfAny(ctx)
@@ -364,7 +364,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		err = svc.VerifyExistingEnterpriseIfAny(ctx)
@@ -405,7 +405,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		err = svc.VerifyExistingEnterpriseIfAny(ctx)
@@ -446,7 +446,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		err = svc.VerifyExistingEnterpriseIfAny(ctx)
@@ -513,7 +513,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 				}
 
 				activityModule := &noopActivityModule{} // This test does not verify activity creation.
-				svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+				svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 				require.NoError(t, err)
 
 				err = svc.VerifyExistingEnterpriseIfAny(ctx)
@@ -543,7 +543,7 @@ func TestVerifyExistingEnterpriseIfAny(t *testing.T) {
 		}
 
 		activityModule := &noopActivityModule{} // This test does not verify activity creation.
-		svc, err := NewServiceWithClient(logger.SlogLogger(), fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
+		svc, err := NewServiceWithClient(logger, fleetDS, &androidAPIClient, "test-private-key", &fleetDS.DataStore, activityModule, config.AndroidAgentConfig{})
 		require.NoError(t, err)
 
 		err = svc.VerifyExistingEnterpriseIfAny(ctx)

server/mdm/android/tests/testing_utils.go

@@ -18,7 +18,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/android/service/androidmgmt"
 	ds_mock "github.com/fleetdm/fleet/v4/server/mock"
 	"github.com/fleetdm/fleet/v4/server/platform/endpointer"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/service/middleware/auth"
 	"github.com/fleetdm/fleet/v4/server/service/middleware/log"
@@ -118,13 +117,12 @@ func (ts *WithServer) SetupSuite(t *testing.T, dbName string) {
 	ts.createCommonProxyMocks(t)
 
 	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	kitLogger := logging.NewLogger(logger)
 	activityModule := &noopActivityModule{} // This test does not verify activity creation.
 	svc, err := service.NewServiceWithClient(logger, &ts.DS, &ts.AndroidAPIClient, "test-private-key", ts.DS.Datastore, activityModule, config.AndroidAgentConfig{})
 	require.NoError(t, err)
 	ts.Svc = svc
 
-	ts.Server = runServerForTests(t, kitLogger, &ts.FleetSvc, svc)
+	ts.Server = runServerForTests(t, logger, &ts.FleetSvc, svc)
 }
 
 func (ts *WithServer) CreateCommonDSMocks() {
@@ -210,7 +208,7 @@ func (m *mockService) NewActivity(ctx context.Context, user *fleet.User, details
 	return m.Called(ctx, user, details).Error(0)
 }
 
-func runServerForTests(t *testing.T, logger *logging.Logger, fleetSvc fleet.Service, androidSvc android.Service) *httptest.Server {
+func runServerForTests(t *testing.T, logger *slog.Logger, fleetSvc fleet.Service, androidSvc android.Service) *httptest.Server {
 	// androidErrorEncoder wraps EncodeError with nil domain encoder for android tests
 	androidErrorEncoder := func(ctx context.Context, err error, w http.ResponseWriter) {
 		endpointer.EncodeError(ctx, err, w, nil)
@@ -221,11 +219,11 @@ func runServerForTests(t *testing.T, logger *logging.Logger, fleetSvc fleet.Serv
 			kithttp.PopulateRequestContext,
 			auth.SetRequestsContexts(fleetSvc),
 		),
-		kithttp.ServerErrorHandler(&endpointer.ErrorHandler{Logger: logger.SlogLogger()}),
+		kithttp.ServerErrorHandler(&endpointer.ErrorHandler{Logger: logger}),
 		kithttp.ServerErrorEncoder(androidErrorEncoder),
 		kithttp.ServerAfter(
 			kithttp.SetContentType("application/json; charset=utf-8"),
-			log.LogRequestEnd(logger.SlogLogger()),
+			log.LogRequestEnd(logger),
 		),
 	}
 

server/mdm/scep/cmd/scepclient/scepclient.go

@@ -18,8 +18,8 @@ import (
 	"time"
 
 	scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/fleetdm/fleet/v4/server/platform/logging"
-
 	"github.com/smallstep/scep"
 )
 
@@ -160,7 +160,7 @@ func run(cfg runCfg) error {
 		}
 	}
 
-	msg, err := scep.NewCSRRequest(csr, tmpl, scep.WithLogger(logging.NewLogger(logger)), scep.WithCertsSelector(cfg.caCertsSelector))
+	msg, err := scep.NewCSRRequest(csr, tmpl, scep.WithLogger(kitlogadapter.NewLogger(logger)), scep.WithCertsSelector(cfg.caCertsSelector))
 	if err != nil {
 		return errors.Join(err, errors.New("creating csr pkiMessage"))
 	}
@@ -176,7 +176,7 @@ func run(cfg runCfg) error {
 			return errors.Join(err, fmt.Errorf("PKIOperation for %s", msgType))
 		}
 
-		respMsg, err = scep.ParsePKIMessage(respBytes, scep.WithLogger(logging.NewLogger(logger)), scep.WithCACerts(caCerts))
+		respMsg, err = scep.ParsePKIMessage(respBytes, scep.WithLogger(kitlogadapter.NewLogger(logger)), scep.WithCACerts(caCerts))
 		if err != nil {
 			return errors.Join(err, fmt.Errorf("parsing pkiMessage response %s", msgType))
 		}

server/mdm/scep/kitlogadapter/kitlogadapter.go

@@ -0,0 +1,88 @@
+// Package kitlogadapter provides a thin adapter that wraps *slog.Logger to
+// implement the go-kit kitlog.Logger interface. This is used at the few
+// remaining boundaries where third-party libraries (go-kit/kit, smallstep/scep, etc.)
+// require a kitlog.Logger.
+package kitlogadapter
+
+import (
+	"context"
+	"log/slog"
+)
+
+// Logger wraps a *slog.Logger to implement the kitlog.Logger interface.
+type Logger struct {
+	logger *slog.Logger
+}
+
+// NewLogger creates a new kitlog adapter using the provided slog.Logger.
+func NewLogger(logger *slog.Logger) *Logger {
+	return &Logger{logger: logger}
+}
+
+// Log implements kitlog.Logger. It converts key-value pairs to slog attributes
+// and logs at the appropriate level based on the "level" key if present.
+func (a *Logger) Log(keyvals ...any) error {
+	if len(keyvals) == 0 {
+		return nil
+	}
+
+	level := slog.LevelInfo
+	msg := ""
+	attrs := make([]slog.Attr, 0, len(keyvals)/2)
+
+	for i := 0; i < len(keyvals)-1; i += 2 {
+		key, ok := keyvals[i].(string)
+		if !ok {
+			continue
+		}
+		val := keyvals[i+1]
+
+		switch key {
+		case "level":
+			level = levelToSlog(val)
+		case "msg":
+			if s, ok := val.(string); ok {
+				msg = s
+			}
+		case "ts":
+			// Skip timestamp — slog handles this automatically
+			continue
+		default:
+			attrs = append(attrs, slog.Any(key, val))
+		}
+	}
+
+	a.logger.LogAttrs(context.Background(), level, msg, attrs...)
+	return nil
+}
+
+// With returns a new Logger with the given key-value pairs added to every log entry.
+func (a *Logger) With(keyvals ...any) *Logger {
+	return &Logger{logger: a.logger.With(keyvals...)}
+}
+
+// levelToSlog converts a kitlog level value to slog.Level.
+func levelToSlog(val any) slog.Level {
+	var levelStr string
+	switch v := val.(type) {
+	case string:
+		levelStr = v
+	case interface{ String() string }:
+		levelStr = v.String()
+	default:
+		return slog.LevelInfo
+	}
+
+	switch levelStr {
+	case "debug":
+		return slog.LevelDebug
+	case "info":
+		return slog.LevelInfo
+	case "warn":
+		return slog.LevelWarn
+	case "error":
+		return slog.LevelError
+	default:
+		return slog.LevelInfo
+	}
+}

server/mdm/scep/kitlogadapter/kitlogadapter_test.go

@@ -0,0 +1,58 @@
+package kitlogadapter
+
+import (
+	"log/slog"
+	"testing"
+
+	"github.com/fleetdm/fleet/v4/server/platform/logging/testutils"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLog(t *testing.T) {
+	t.Parallel()
+
+	t.Run("basic key-value logging", func(t *testing.T) {
+		handler := testutils.NewTestHandler()
+		adapter := NewLogger(slog.New(handler))
+
+		err := adapter.Log("msg", "hello world", "key", "value")
+		require.NoError(t, err)
+
+		record := handler.LastRecord()
+		require.NotNil(t, record)
+		assert.Equal(t, "hello world", record.Message)
+
+		attrs := testutils.RecordAttrs(record)
+		assert.Equal(t, "value", attrs["key"])
+	})
+
+	t.Run("with context via With", func(t *testing.T) {
+		handler := testutils.NewTestHandler()
+		adapter := NewLogger(slog.New(handler))
+
+		contextLogger := adapter.With("component", "test-component")
+		err := contextLogger.Log("msg", "message with context")
+		require.NoError(t, err)
+
+		record := handler.LastRecord()
+		require.NotNil(t, record)
+		assert.Equal(t, "message with context", record.Message)
+
+		attrs := testutils.RecordAttrs(record)
+		assert.Equal(t, "test-component", attrs["component"])
+	})
+
+	t.Run("level mapping", func(t *testing.T) {
+		handler := testutils.NewTestHandler()
+		adapter := NewLogger(slog.New(handler))
+
+		err := adapter.Log("level", "error", "msg", "something broke")
+		require.NoError(t, err)
+
+		record := handler.LastRecord()
+		require.NotNil(t, record)
+		assert.Equal(t, slog.LevelError, record.Level)
+		assert.Equal(t, "something broke", record.Message)
+	})
+}

server/mdm/scep/server/service.go

@@ -7,7 +7,7 @@ import (
 	"errors"
 	"log/slog"
 
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/smallstep/scep"
 )
 
@@ -116,7 +116,7 @@ func (svc *service) PKIOperation(ctx context.Context, data []byte) ([]byte, erro
 	if len(data) == 0 {
 		return nil, &BadRequestError{Message: "missing data for PKIOperation"}
 	}
-	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(logging.NewLogger(svc.debugLogger)))
+	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(kitlogadapter.NewLogger(svc.debugLogger)))
 	if err != nil {
 		return nil, err
 	}

server/mdm/scep/server/transport.go

@@ -11,7 +11,7 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	"github.com/go-kit/kit/transport"
 	kithttp "github.com/go-kit/kit/transport/http"
 	"github.com/gorilla/mux"
@@ -19,7 +19,7 @@ import (
 )
 
 func MakeHTTPHandler(e *Endpoints, svc Service, logger *slog.Logger) http.Handler {
-	kitLogger := logging.NewLogger(logger)
+	kitLogger := kitlogadapter.NewLogger(logger)
 	opts := []kithttp.ServerOption{
 		kithttp.ServerErrorLogger(kitLogger),
 		kithttp.ServerFinalizer(logutil.NewHTTPLogger(kitLogger).LoggingFinalizer),
@@ -43,7 +43,7 @@ func MakeHTTPHandler(e *Endpoints, svc Service, logger *slog.Logger) http.Handle
 }
 
 func MakeHTTPHandlerWithIdentifier(e *Endpoints, rootPath string, logger *slog.Logger) http.Handler {
-	kitLogger := logging.NewLogger(logger)
+	kitLogger := kitlogadapter.NewLogger(logger)
 	opts := []kithttp.ServerOption{
 		kithttp.ServerErrorHandler(transport.NewLogErrorHandler(kitLogger)),
 		kithttp.ServerFinalizer(logutil.NewHTTPLogger(kitLogger).LoggingFinalizer),

server/platform/logging/kitlog_adapter.go

@@ -1,125 +0,0 @@
-package logging
-
-import (
-	"context"
-	"log/slog"
-)
-
-// Logger wraps a slog.Logger to implement the kitlog.Logger interface.
-// This allows gradual migration from kitlog to slog by providing a drop-in
-// replacement that uses slog under the hood.
-type Logger struct {
-	logger *slog.Logger
-}
-
-// NewLogger creates a new adapter that implements kitlog.Logger
-// using the provided slog.Logger. It returns *Logger to preserve
-// type information, allowing callers to access SlogLogger() directly.
-func NewLogger(logger *slog.Logger) *Logger {
-	return &Logger{
-		logger: logger,
-	}
-}
-
-// Log implements kitlog.Logger. It converts key-value pairs to slog attributes
-// and logs at the appropriate level based on the "level" key if present.
-func (a *Logger) Log(keyvals ...any) error {
-	if len(keyvals) == 0 {
-		return nil
-	}
-
-	// Extract level and message from keyvals
-	level := slog.LevelInfo
-	msg := ""
-	attrs := make([]slog.Attr, 0, len(keyvals)/2)
-
-	for i := 0; i < len(keyvals)-1; i += 2 {
-		key, ok := keyvals[i].(string)
-		if !ok {
-			// If key isn't a string, skip this pair
-			continue
-		}
-		val := keyvals[i+1]
-
-		switch key {
-		case "level":
-			level = kitlogLevelToSlog(val)
-		case "msg":
-			if s, ok := val.(string); ok {
-				msg = s
-			}
-		case "ts":
-			// Skip timestamp - slog handles this automatically
-			continue
-		default:
-			attrs = append(attrs, slog.Any(key, val))
-		}
-	}
-
-	a.logger.LogAttrs(context.Background(), level, msg, attrs...)
-	return nil
-}
-
-// With returns a new logger with the given key-value pairs added to every log.
-// It returns *Logger (not kitlog.Logger) to preserve type information,
-// allowing callers to access SlogLogger() without type assertions.
-func (a *Logger) With(keyvals ...any) *Logger {
-	return &Logger{
-		logger: a.logger.With(keyvals...),
-	}
-}
-
-// kitlogLevelToSlog converts a kitlog level value to slog.Level.
-func kitlogLevelToSlog(val any) slog.Level {
-	// kitlog uses level.Value which implements fmt.Stringer
-	// Common values are "debug", "info", "warn", "error"
-	var levelStr string
-
-	switch v := val.(type) {
-	case string:
-		levelStr = v
-	case interface{ String() string }:
-		levelStr = v.String()
-	default:
-		return slog.LevelInfo
-	}
-
-	switch levelStr {
-	case "debug":
-		return slog.LevelDebug
-	case "info":
-		return slog.LevelInfo
-	case "warn":
-		return slog.LevelWarn
-	case "error":
-		return slog.LevelError
-	default:
-		return slog.LevelInfo
-	}
-}
-
-// SlogLogger returns the underlying slog.Logger.
-// This is useful when migrating code from kitlog to slog.
-func (a *Logger) SlogLogger() *slog.Logger {
-	return a.logger
-}
-
-// Wrap slog's ErrorContext method.
-func (a *Logger) ErrorContext(ctx context.Context, msg string, keyvals ...any) {
-	a.logger.ErrorContext(ctx, msg, keyvals...)
-}
-
-// Wrap slog's WarnContext method.
-func (a *Logger) WarnContext(ctx context.Context, msg string, keyvals ...any) {
-	a.logger.WarnContext(ctx, msg, keyvals...)
-}
-
-// Wrap slog's InfoContext method.
-func (a *Logger) InfoContext(ctx context.Context, msg string, keyvals ...any) {
-	a.logger.InfoContext(ctx, msg, keyvals...)
-}
-
-// Wrap slog's DebugContext method.
-func (a *Logger) DebugContext(ctx context.Context, msg string, keyvals ...any) {
-	a.logger.DebugContext(ctx, msg, keyvals...)
-}

server/platform/logging/kitlog_adapter_test.go

@@ -1,94 +0,0 @@
-package logging
-
-import (
-	"context"
-	"log/slog"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/fleetdm/fleet/v4/server/platform/logging/testutils"
-)
-
-func TestKitlogAdapter(t *testing.T) {
-	t.Parallel()
-	handler := testutils.NewTestHandler()
-	adapter := NewLogger(slog.New(handler))
-
-	t.Run("basic logging via Log method", func(t *testing.T) {
-		t.Parallel()
-
-		err := adapter.Log("msg", "hello world", "key", "value")
-		require.NoError(t, err)
-
-		record := handler.LastRecord()
-		require.NotNil(t, record)
-		assert.Equal(t, "hello world", record.Message)
-
-		attrs := testutils.RecordAttrs(record)
-		assert.Equal(t, "value", attrs["key"])
-	})
-
-	t.Run("with context via With", func(t *testing.T) {
-		t.Parallel()
-
-		contextLogger := adapter.With("component", "test-component")
-		err := contextLogger.Log("msg", "message with context")
-		require.NoError(t, err)
-
-		record := handler.LastRecord()
-		require.NotNil(t, record)
-		assert.Equal(t, "message with context", record.Message)
-
-		attrs := testutils.RecordAttrs(record)
-		assert.Equal(t, "test-component", attrs["component"])
-	})
-}
-
-func TestKitlogSlogWrappers(t *testing.T) {
-	t.Parallel()
-	handler := testutils.NewTestHandler()
-	adapter := NewLogger(slog.New(handler))
-
-	tests := []struct {
-		name          string
-		logFunc       func(ctx context.Context, msg string, keyvals ...any)
-		expectedLevel slog.Level
-	}{
-		{
-			name:          "error",
-			logFunc:       adapter.ErrorContext,
-			expectedLevel: slog.LevelError,
-		},
-		{
-			name:          "warn",
-			logFunc:       adapter.WarnContext,
-			expectedLevel: slog.LevelWarn,
-		},
-		{
-			name:          "info",
-			logFunc:       adapter.InfoContext,
-			expectedLevel: slog.LevelInfo,
-		},
-		{
-			name:          "debug",
-			logFunc:       adapter.DebugContext,
-			expectedLevel: slog.LevelDebug,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			tc.logFunc(t.Context(), tc.name+" message", "key", "value")
-
-			record := handler.LastRecord()
-			require.NotNil(t, record)
-			assert.Equal(t, tc.name+" message", record.Message)
-			assert.Equal(t, tc.expectedLevel, record.Level)
-
-			attrs := testutils.RecordAttrs(record)
-			assert.Equal(t, "value", attrs["key"])
-		})
-	}
-}

server/platform/logging/logging.go

@@ -155,21 +155,3 @@ func (h *OtelTracingHandler) WithGroup(name string) slog.Handler {
 
 // Ensure OtelTracingHandler implements slog.Handler at compile time.
 var _ slog.Handler = (*OtelTracingHandler)(nil)
-
-// NewNopLogger returns a no-op *Logger that discards all log output.
-// Use this in tests instead of kitlog.NewNopLogger() to maintain type safety.
-func NewNopLogger() *Logger {
-	return NewLogger(slog.New(slog.DiscardHandler))
-}
-
-// NewLogfmtLogger creates a *Logger that outputs text-formatted logs to the given writer.
-// This is a drop-in replacement for kitlog.NewLogfmtLogger().
-func NewLogfmtLogger(output io.Writer) *Logger {
-	return NewLogger(NewSlogLogger(Options{Output: output, Debug: true}))
-}
-
-// NewJSONLogger creates a *Logger that outputs JSON-formatted logs to the given writer.
-// This is a drop-in replacement for kitlog.NewJSONLogger().
-func NewJSONLogger(output io.Writer) *Logger {
-	return NewLogger(NewSlogLogger(Options{Output: output, JSON: true, Debug: true}))
-}

server/service/integration_enterprise_test.go

@@ -51,7 +51,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/live_query/live_query_mock"
 	"github.com/fleetdm/fleet/v4/server/mdm"
 	maintained_apps "github.com/fleetdm/fleet/v4/server/mdm/maintainedapps"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/policies"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/pubsub"
@@ -114,7 +113,7 @@ func (s *integrationEnterpriseTestSuite) SetupSuite() {
 		Pool:           s.redisPool,
 		Rs:             pubsub.NewInmemQueryResults(),
 		Lq:             s.lq,
-		Logger:         logging.NewLogfmtLogger(os.Stdout),
+		Logger:         slog.New(slog.NewTextHandler(os.Stdout, nil)),
 		EnableCachedDS: true,
 		StartCronSchedules: []TestNewScheduleFunc{
 			func(ctx context.Context, ds fleet.Datastore) fleet.NewCronScheduleFunc {
@@ -139,7 +138,7 @@ func (s *integrationEnterpriseTestSuite) SetupSuite() {
 		DBConns:                         s.dbConns,
 	}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		config.Logger = logging.NewNopLogger()
+		config.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(s.T(), s.ds, &config)
 	s.server = server
@@ -12672,10 +12671,10 @@ func (s *integrationEnterpriseTestSuite) TestSoftwareInstallerUploadDownloadAndD
 		}
 		s.uploadSoftwareInstaller(t, payload, http.StatusOK, "")
 
-		logger := logging.NewLogfmtLogger(os.Stderr)
+		logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
 
 		// Run the migration when nothing is to be done
-		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger.SlogLogger())
+		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger)
 		require.NoError(t, err)
 
 		// check the software installer
@@ -12713,7 +12712,7 @@ func (s *integrationEnterpriseTestSuite) TestSoftwareInstallerUploadDownloadAndD
 		assert.Equal(t, "exit 1", respTitle.SoftwareTitle.SoftwarePackage.UninstallScript)
 
 		// Run the migration
-		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger.SlogLogger())
+		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger)
 		require.NoError(t, err)
 
 		// Check package ID and extension
@@ -12746,7 +12745,7 @@ func (s *integrationEnterpriseTestSuite) TestSoftwareInstallerUploadDownloadAndD
 		assert.Equal(t, uninstallScript, respTitle.SoftwareTitle.SoftwarePackage.UninstallScript)
 
 		// Running the migration again causes no issues.
-		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger.SlogLogger())
+		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger)
 		require.NoError(t, err)
 
 		// Update DB by clearing package ids and swapping extension to one we skip
@@ -12759,7 +12758,7 @@ func (s *integrationEnterpriseTestSuite) TestSoftwareInstallerUploadDownloadAndD
 		})
 
 		// Running the migration again causes no issues.
-		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger.SlogLogger())
+		err = eeservice.UninstallSoftwareMigration(context.Background(), s.ds, s.softwareInstallStore, logger)
 		require.NoError(t, err)
 
 		// Package ID and extension should not have been modified

server/service/integration_install_test.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -19,7 +20,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/s3"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	software_mock "github.com/fleetdm/fleet/v4/server/mock/software"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/assert"
@@ -53,13 +53,13 @@ func (s *integrationInstallTestSuite) SetupSuite() {
 		License: &fleet.LicenseInfo{
 			Tier: fleet.TierPremium,
 		},
-		Logger:               logging.NewLogfmtLogger(os.Stdout),
+		Logger:               slog.New(slog.NewTextHandler(os.Stdout, nil)),
 		EnableCachedDS:       true,
 		SoftwareInstallStore: softwareInstallStore,
 		FleetConfig:          &fleetConfig,
 	}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		installConfig.Logger = logging.NewNopLogger()
+		installConfig.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(s.T(), s.ds, &installConfig)
 	s.server = server

server/service/integration_live_queries_test.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"math/rand"
 	"net/http"
 	"os"
@@ -19,7 +20,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/live_query/live_query_mock"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/pubsub"
 	"github.com/google/uuid"
@@ -61,7 +61,7 @@ func (s *liveQueriesTestSuite) SetupSuite() {
 
 	opts := &TestServerOpts{Lq: lq, Rs: rs, DBConns: s.dbConns}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		opts.Logger = logging.NewNopLogger()
+		opts.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(s.T(), s.ds, opts)
 	s.server = server

server/service/integration_logger_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	microsoft_mdm "github.com/fleetdm/fleet/v4/server/mdm/microsoft"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/platform/logging/testutils"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/service/contract"
@@ -43,7 +42,7 @@ func (s *integrationLoggerTestSuite) SetupSuite() {
 	s.withDS.SetupSuite("integrationLoggerTestSuite")
 
 	s.handler = testutils.NewTestHandler()
-	logger := logging.NewLogger(slog.New(s.handler))
+	logger := slog.New(s.handler)
 	redisPool := redistest.SetupRedis(s.T(), "zz", false, false, false)
 
 	users, server := RunServerForTestsWithDS(s.T(), s.ds, &TestServerOpts{

server/service/integration_mdm_ddm_test.go

@@ -845,7 +845,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	require.Nil(t, hostResp.Host.MDM.Profiles)
 
 	// trigger the reconciler, no error
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	// declarativeManagement command is not sent.
@@ -856,7 +856,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	addDeclaration("I2", 0, nil)
 
 	// reconcile again, this time new declarations were added
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	// TODO: check command is pending
@@ -865,7 +865,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	checkDDMSync(device)
 
 	// reconcile again, commands for the uploaded declarations are already sent
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// no new commands are sent
 	checkNoCommands(device)
@@ -873,7 +873,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	// delete a declaration
 	deleteDeclaration(d1UUID)
 	// reconcile again
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// a DDM sync is triggered
 	checkDDMSync(device)
@@ -881,7 +881,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	// add a new host
 	_, deviceTwo := createHostThenEnrollMDM(s.ds, s.server.URL, t)
 	// reconcile again
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// DDM sync is triggered only for the new host
 	checkNoCommands(device)
@@ -892,7 +892,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 		addHostsToTeamRequest{TeamID: &team.ID, HostIDs: []uint{mdmHost.ID}}, http.StatusOK)
 
 	// reconcile
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	// DDM sync is triggered only for the transferred host
@@ -901,7 +901,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	checkNoCommands(deviceTwo)
 
 	// reconcile
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// nobody receives commands this time
 	checkNoCommands(device)
@@ -912,7 +912,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	addDeclaration("I2", team.ID, nil)
 
 	// reconcile
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// DDM sync is triggered for the host in the team
 	checkDDMSync(device)
@@ -924,7 +924,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 		addHostsToTeamRequest{TeamID: &team.ID, HostIDs: []uint{mdmHostThree.ID}}, http.StatusOK)
 
 	// reconcile
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// DDM sync is triggered only for the new host
 	checkNoCommands(device)
@@ -932,7 +932,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	checkDDMSync(deviceThree)
 
 	// no new commands after another reconciliation
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	checkNoCommands(device)
 	checkNoCommands(deviceTwo)
@@ -957,7 +957,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMReconciliation() {
 	addDeclaration("I3", team.ID, []string{label.Name})
 
 	// reconcile
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	// DDM sync is triggered only for the host with the label
 	checkNoCommands(device)
@@ -989,7 +989,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMStatusReport() {
 	s.Do("POST", "/api/v1/fleet/mdm/profiles/batch", batchSetMDMProfilesRequest{Profiles: declarations}, http.StatusNoContent)
 
 	// reconcile profiles
-	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	// declarations are ("install", "pending") after the cron run
@@ -1084,7 +1084,7 @@ func (s *integrationMDMTestSuite) TestAppleDDMStatusReport() {
 	s.Do("POST", "/api/v1/fleet/mdm/profiles/batch", batchSetMDMProfilesRequest{Profiles: declarations}, http.StatusNoContent)
 
 	// reconcile profiles
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	assertHostDeclarations(mdmHost.UUID, []*fleet.MDMAppleHostDeclaration{
 		{Identifier: "I1", Status: &fleet.MDMDeliveryVerified, OperationType: fleet.MDMOperationTypeInstall},
@@ -1139,7 +1139,7 @@ func (s *integrationMDMTestSuite) TestDDMUnsupportedDevice() {
 	s.Do("POST", "/api/v1/fleet/mdm/profiles/batch", batchSetMDMProfilesRequest{Profiles: declarations}, http.StatusNoContent)
 
 	// reconcile declarations
-	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	// declaration is pending
@@ -1232,7 +1232,7 @@ func (s *integrationMDMTestSuite) TestDDMTransactionRecording() {
 	s.Do("POST", "/api/v1/fleet/mdm/profiles/batch", batchSetMDMProfilesRequest{Profiles: declarations}, http.StatusNoContent)
 
 	// reconcile declarations
-	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	_, mdmDevice := createHostThenEnrollMDM(s.ds, s.server.URL, t)
@@ -1263,7 +1263,7 @@ func (s *integrationMDMTestSuite) TestDDMTransactionRecording() {
 
 	// a second device requests tokens
 	_, mdmDeviceTwo := createHostThenEnrollMDM(s.ds, s.server.URL, t)
-	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 
 	_, err = mdmDeviceTwo.DeclarativeManagement("tokens")

server/service/integration_mdm_lifecycle_test.go

@@ -9,6 +9,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -27,7 +28,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/nanodep/godep"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanomdm/mdm"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanomdm/push"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/google/uuid"
 	"github.com/jmoiron/sqlx"
@@ -920,10 +920,10 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	require.NoError(t, err)
 	fleetCfg := config.TestConfig()
 	config.SetTestMDMConfig(s.T(), &fleetCfg, cert, key, "")
-	logger := logging.NewJSONLogger(os.Stdout)
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
 	// run without expired certs, no command enqueued
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 	cmd, err := manualEnrolledDevice.Idle()
 	require.NoError(t, err)
@@ -960,7 +960,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	expireCerts()
 
 	// generate a new config here so we can manipulate the certs.
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 
 	checkRenewCertCommand := func(device *mdmtest.TestAppleMDMClient, enrollRef string, wantProfile string, wantManagedAppleID string) {
@@ -1013,12 +1013,12 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 
 	// set the env var, and run the cron
 	t.Setenv("FLEET_SILENT_MIGRATION_ENROLLMENT_PROFILE", base64.StdEncoding.EncodeToString([]byte("<foo></foo>")))
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 	checkRenewCertCommand(migratedDevice, "", "<foo></foo>", "")
 
 	// another cron run shouldn't enqueue more commands
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 
 	cmd, err = manualEnrolledDevice.Idle()
@@ -1085,7 +1085,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	}
 	resp := deleteHostsResponse{}
 	s.DoJSON("POST", "/api/latest/fleet/hosts/delete", req, http.StatusOK, &resp)
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 	checkRenewCertCommand(automaticEnrolledDevice, "", "", "")
 	checkRenewCertCommand(automaticEnrolledDeviceWithRef, "foo", "", "")
@@ -1116,7 +1116,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	require.Empty(t, getEnrollRef(iPadMdmDevice.UUID))
 
 	// enqueue refetch commands and report results
-	require.NoError(t, apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger(), func(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails) error {
+	require.NoError(t, apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger, func(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails) error {
 		return nil
 	}))
 	require.True(t, existsRefetchCmd(iPadMdmDevice.UUID))
@@ -1141,7 +1141,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	require.False(t, renewCmdUUID.Valid)
 
 	// running cron enqueues the renew command
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 
 	// we now have a renew command uuid
@@ -1165,7 +1165,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	require.Nil(t, cmd) // error doesn't trigger new command immediately
 
 	// running cron again doesn't change anything if the renew command failed
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 	cmd, err = iPadMdmDevice.Idle()
 	require.NoError(t, err)
@@ -1189,7 +1189,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	require.Empty(t, getEnrollRef(iPadMdmDevice.UUID))
 
 	// running cron again doesn't change anything until refetch is done
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 	cmd, err = iPadMdmDevice.Idle()
 	require.NoError(t, err)
@@ -1212,7 +1212,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	})
 
 	// enqueue refetch commands and report results
-	require.NoError(t, apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger(), func(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails) error {
+	require.NoError(t, apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger, func(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails) error {
 		return nil
 	}))
 	require.True(t, existsRefetchCmd(iPadMdmDevice.UUID))
@@ -1238,7 +1238,7 @@ func (s *integrationMDMTestSuite) TestLifecycleSCEPCertExpiration() {
 	})
 
 	// now run renewal cron to issue new command
-	err = RenewSCEPCertificates(ctx, logger.SlogLogger(), s.ds, &fleetCfg, s.mdmCommander)
+	err = RenewSCEPCertificates(ctx, logger, s.ds, &fleetCfg, s.mdmCommander)
 	require.NoError(t, err)
 
 	renewCmdUUID = getRenewCmdUUID(iPadMdmDevice.UUID)

server/service/integration_mdm_profiles_test.go

@@ -520,7 +520,7 @@ func (s *integrationMDMTestSuite) TestAppleProfileManagement() {
 	declUUID := resp.ProfileUUID
 
 	checkDDMSync := func(d *mdmtest.TestAppleMDMClient) {
-		require.NoError(t, ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger()))
+		require.NoError(t, ReconcileAppleDeclarations(ctx, s.ds, s.mdmCommander, s.logger))
 		cmd, err := d.Idle()
 		require.NoError(t, err)
 		require.NotNil(t, cmd)
@@ -5263,7 +5263,7 @@ func (s *integrationMDMTestSuite) TestMDMBatchSetProfilesKeepsReservedNames() {
 	if len(secrets) == 0 {
 		require.NoError(t, s.ds.ApplyEnrollSecrets(ctx, nil, []*fleet.EnrollSecret{{Secret: t.Name()}}))
 	}
-	require.NoError(t, ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger()))
+	require.NoError(t, ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger))
 
 	// turn on disk encryption and os updates
 	s.DoJSON("PATCH", "/api/latest/fleet/config", json.RawMessage(`{
@@ -5343,7 +5343,7 @@ func (s *integrationMDMTestSuite) TestMDMBatchSetProfilesKeepsReservedNames() {
 	require.Equal(t, "13.3.8", tmResp.Team.Config.MDM.MacOSUpdates.MinimumVersion.Value)
 	require.Equal(t, true, tmResp.Team.Config.MDM.MacOSUpdates.UpdateNewHosts.Value)
 
-	require.NoError(t, ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger()))
+	require.NoError(t, ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger))
 
 	checkMacProfs(&tmResp.Team.ID, servermdm.ListFleetReservedMacOSProfileNames()...)
 	checkWinProfs(&tmResp.Team.ID, servermdm.ListFleetReservedWindowsProfileNames()...)

server/service/integration_mdm_test.go

@@ -79,7 +79,6 @@ import (
 	nanomdm_pushsvc "github.com/fleetdm/fleet/v4/server/mdm/nanomdm/push/service"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
 	mdmtesting "github.com/fleetdm/fleet/v4/server/mdm/testing_utils"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/service/contract"
 	"github.com/fleetdm/fleet/v4/server/service/integrationtest/scep_server"
@@ -128,7 +127,7 @@ type integrationMDMTestSuite struct {
 	// Flag to skip jobs processing by worker
 	skipWorkerJobs            atomic.Bool
 	mdmCommander              *apple_mdm.MDMAppleCommander
-	logger                    *logging.Logger
+	logger                    *slog.Logger
 	scepChallenge             string
 	appleVPPConfigSrv         *httptest.Server
 	appleVPPConfigSrvConfig   *appleVPPConfigSrvConf
@@ -202,24 +201,24 @@ func (s *integrationMDMTestSuite) SetupSuite() {
 	scepStorage, err := s.ds.NewSCEPDepot()
 	require.NoError(s.T(), err)
 
-	pushLog := logging.NewJSONLogger(os.Stdout)
+	pushLog := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		pushLog = logging.NewNopLogger()
+		pushLog = slog.New(slog.DiscardHandler)
 	}
 	pushFactory, pushProvider := newMockAPNSPushProviderFactory()
 	mdmPushService := nanomdm_pushsvc.New(
 		mdmStorage,
 		mdmStorage,
 		pushFactory,
-		NewNanoMDMLogger(pushLog.SlogLogger()),
+		NewNanoMDMLogger(pushLog),
 	)
 	mdmCommander := apple_mdm.NewMDMAppleCommander(mdmStorage, mdmPushService)
 	s.redisPool = redistest.SetupRedis(s.T(), "zz", false, false, false)
 	s.withServer.lq = live_query_mock.New(s.T())
 
-	wlog := logging.NewJSONLogger(os.Stdout)
+	wlog := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		wlog = logging.NewNopLogger()
+		wlog = slog.New(slog.DiscardHandler)
 	}
 
 	activityModule := activitiesmod.NewActivityModule()
@@ -227,7 +226,7 @@ func (s *integrationMDMTestSuite) SetupSuite() {
 	androidMockClient.SetAuthenticationSecretFunc = func(secret string) error {
 		return nil
 	}
-	androidSvc, err := android_service.NewServiceWithClient(wlog.SlogLogger(), s.ds, androidMockClient, "test-private-key", s.ds, activityModule, config.AndroidAgentConfig{
+	androidSvc, err := android_service.NewServiceWithClient(wlog, s.ds, androidMockClient, "test-private-key", s.ds, activityModule, config.AndroidAgentConfig{
 		Package:       "com.fleetdm.agent",
 		SigningSHA256: "abc123def456",
 	})
@@ -239,26 +238,26 @@ func (s *integrationMDMTestSuite) SetupSuite() {
 
 	macosJob := &worker.MacosSetupAssistant{
 		Datastore:  s.ds,
-		Log:        wlog.SlogLogger(),
-		DEPService: apple_mdm.NewDEPService(s.ds, depStorage, wlog.SlogLogger()),
-		DEPClient:  apple_mdm.NewDEPClient(depStorage, s.ds, wlog.SlogLogger()),
+		Log:        wlog,
+		DEPService: apple_mdm.NewDEPService(s.ds, depStorage, wlog),
+		DEPClient:  apple_mdm.NewDEPClient(depStorage, s.ds, wlog),
 	}
 	appleMDMJob := &worker.AppleMDM{
 		Datastore: s.ds,
-		Log:       wlog.SlogLogger(),
+		Log:       wlog,
 		Commander: mdmCommander,
 	}
 	vppVerifyJob := &worker.AppleSoftware{
 		Datastore: s.ds,
-		Log:       wlog.SlogLogger(),
+		Log:       wlog,
 		Commander: mdmCommander,
 	}
 	softwareWorker := &worker.SoftwareWorker{
 		Datastore:     s.ds,
-		Log:           wlog.SlogLogger(),
+		Log:           wlog,
 		AndroidModule: androidSvc,
 	}
-	workr := worker.NewWorker(s.ds, wlog.SlogLogger())
+	workr := worker.NewWorker(s.ds, wlog)
 	workr.TestIgnoreUnknownJobs = true
 	workr.Register(macosJob, appleMDMJob, vppVerifyJob, softwareWorker)
 
@@ -278,9 +277,9 @@ func (s *integrationMDMTestSuite) SetupSuite() {
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
 		cronLog = slog.New(slog.DiscardHandler)
 	}
-	serverLogger := logging.NewJSONLogger(os.Stdout)
+	serverLogger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		serverLogger = logging.NewNopLogger()
+		serverLogger = slog.New(slog.DiscardHandler)
 	}
 
 	var softwareInstallerStore fleet.SoftwareInstallerStore
@@ -295,7 +294,7 @@ func (s *integrationMDMTestSuite) SetupSuite() {
 	}
 	s.softwareInstallerStore = softwareInstallerStore
 	scepTimeout := ptr.Duration(10 * time.Second)
-	s.scepConfig = eeservice.NewSCEPConfigService(serverLogger.SlogLogger(), scepTimeout).(*eeservice.SCEPConfigService)
+	s.scepConfig = eeservice.NewSCEPConfigService(serverLogger, scepTimeout).(*eeservice.SCEPConfigService)
 
 	// Create a software title icon store
 	iconDir := s.T().TempDir()
@@ -942,7 +941,7 @@ func (s *integrationMDMTestSuite) mockDEPResponse(orgName string, handler http.H
 	t := s.T()
 	srv := httptest.NewServer(handler)
 	err := s.depStorage.StoreConfig(context.Background(), orgName, &nanodep_client.Config{BaseURL: srv.URL})
-	depSvc := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger.SlogLogger())
+	depSvc := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger)
 	require.NoError(t, depSvc.CreateDefaultAutomaticProfile(context.Background()))
 	require.NoError(t, err)
 	t.Cleanup(func() {
@@ -1324,7 +1323,7 @@ func (s *integrationMDMTestSuite) TestABMExpiredToken() {
 	require.False(t, config.MDM.AppleBMTermsExpired)
 
 	ctx := context.Background()
-	fleetSyncer := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger.SlogLogger())
+	fleetSyncer := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger)
 
 	// not signed error flips the AppleBMTermsExpired flag
 	returnType = "not_signed"
@@ -10346,7 +10345,7 @@ func (s *integrationMDMTestSuite) runWorkerUntilDoneWithChecks(failIfFailedJobs
 
 func (s *integrationMDMTestSuite) runDEPSchedule() {
 	ctx := context.Background()
-	fleetSyncer := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger.SlogLogger())
+	fleetSyncer := apple_mdm.NewDEPService(s.ds, s.depStorage, s.logger)
 	err := fleetSyncer.RunAssigner(ctx)
 	require.NoError(s.T(), err)
 }
@@ -11423,7 +11422,7 @@ func (s *integrationMDMTestSuite) enableABM(orgName string) *fleet.ABMToken {
 			_, _ = w.Write([]byte(`{}`))
 		}
 	}))
-	depClient := apple_mdm.NewDEPClient(s.depStorage, s.ds, s.logger.SlogLogger())
+	depClient := apple_mdm.NewDEPClient(s.depStorage, s.ds, s.logger)
 	_, err = depClient.AccountDetail(ctx, orgName)
 	require.NoError(t, err)
 	return tok
@@ -11722,13 +11721,13 @@ func (s *integrationMDMTestSuite) TestAPNsPushCron() {
 	}
 
 	// trigger the reconciliation schedule
-	err := ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 1)
 	recordedPushes = nil
 
 	// triggering the schedule again doesn't send any more pushes
-	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 0)
 	recordedPushes = nil
@@ -11736,7 +11735,7 @@ func (s *integrationMDMTestSuite) TestAPNsPushCron() {
 	// the cron to trigger pushes sends a new push request each time it
 	// runs if there are pending commands
 	for i := 0; i < 3; i++ {
-		err := SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+		err := SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger)
 		require.NoError(t, err)
 		require.Len(t, recordedPushes, 1)
 		recordedPushes = nil
@@ -11752,7 +11751,7 @@ func (s *integrationMDMTestSuite) TestAPNsPushCron() {
 	}
 
 	// no more pushes are enqueued
-	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 0)
 }
@@ -11783,7 +11782,7 @@ func (s *integrationMDMTestSuite) TestAPNsPushWithNotNow() {
 	}
 
 	// trigger the reconciliation schedule
-	err := ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 1)
 	recordedPushes = nil
@@ -11804,13 +11803,13 @@ func (s *integrationMDMTestSuite) TestAPNsPushWithNotNow() {
 	}}, http.StatusNoContent)
 
 	// trigger the reconciliation schedule
-	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 1)
 	recordedPushes = nil
 
 	// The cron to trigger pushes sends a new push request each time it runs.
-	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 1)
 	recordedPushes = nil
@@ -11824,7 +11823,7 @@ func (s *integrationMDMTestSuite) TestAPNsPushWithNotNow() {
 	assert.Nil(t, cmd)
 
 	// A 'NotNow' command will not trigger a new push. Device is expected to check in again when conditions change.
-	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = ReconcileAppleProfiles(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	require.Len(t, recordedPushes, 0)
 	recordedPushes = nil
@@ -11838,7 +11837,7 @@ func (s *integrationMDMTestSuite) TestAPNsPushWithNotNow() {
 	assert.Nil(t, cmd)
 
 	// no more pushes are enqueued
-	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err = SendPushesToPendingDevices(ctx, s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	assert.Zero(t, recordedPushes)
 }
@@ -18768,7 +18767,7 @@ func (s *integrationMDMTestSuite) TestRecreateDeletedIPhoneBYOD() {
 		pushMutex.Unlock()
 		return mockSuccessfulPush(ctx, pushes)
 	}
-	err := apple_mdm.IOSiPadOSRevive(context.Background(), s.ds, s.mdmCommander, s.logger.SlogLogger())
+	err := apple_mdm.IOSiPadOSRevive(context.Background(), s.ds, s.mdmCommander, s.logger)
 	require.NoError(t, err)
 	pushMutex.Lock()
 	require.Len(t, recordedPushes, 1)
@@ -19742,7 +19741,7 @@ func (s *integrationMDMTestSuite) TestIOSiPadOSRefetch() {
 		return nil, errors.New("unknown device")
 	}
 
-	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger(), s.fleetSvc.NewActivity)
+	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger, s.fleetSvc.NewActivity)
 	require.NoError(s.T(), err) // Verify it not longer throws an error
 
 	// Verify successful is still enrolled
@@ -20756,7 +20755,7 @@ func (s *integrationMDMTestSuite) TestInstalledApplicationListCommandForBYODiDev
 	checkExpectedCommands(mdmClientDEP, false, 1)
 
 	// run the cron-based refetch, will not do anything as the devices were just refetched
-	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger(), s.fleetSvc.NewActivity)
+	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger, s.fleetSvc.NewActivity)
 	require.NoError(t, err)
 
 	checkExpectedCommands(mdmClientBYOD, true, 0)
@@ -20769,7 +20768,7 @@ func (s *integrationMDMTestSuite) TestInstalledApplicationListCommandForBYODiDev
 	require.NoError(t, s.ds.UpdateHost(ctx, hostDEP))
 
 	// run the cron-based refetch again, will enqueue the commands with the correct managed only flag
-	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger.SlogLogger(), s.fleetSvc.NewActivity)
+	err = apple_mdm.IOSiPadOSRefetch(ctx, s.ds, s.mdmCommander, s.logger, s.fleetSvc.NewActivity)
 	require.NoError(t, err)
 
 	checkExpectedCommands(mdmClientBYOD, true, 1)

server/service/integration_smtp_test.go

@@ -2,11 +2,11 @@ package service
 
 import (
 	"encoding/json"
+	"log/slog"
 	"net/http"
 	"os"
 	"testing"
 
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
@@ -23,7 +23,7 @@ func (s *integrationSMTPTestSuite) SetupSuite() {
 		UseMailService: true,
 	}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		opts.Logger = logging.NewNopLogger()
+		opts.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(
 		s.T(),

server/service/integration_sso_test.go

@@ -9,6 +9,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/cookiejar"
 	"net/url"
@@ -23,7 +24,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/test"
 	"github.com/jmoiron/sqlx"
@@ -43,7 +43,7 @@ func (s *integrationSSOTestSuite) SetupSuite() {
 	pool := redistest.SetupRedis(s.T(), "zz", false, false, false)
 	opts := &TestServerOpts{Pool: pool, DBConns: s.dbConns}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		opts.Logger = logging.NewNopLogger()
+		opts.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(s.T(), s.ds, opts)
 	s.server = server

server/service/integrationtest/android/suite.go

@@ -1,6 +1,7 @@
 package android
 
 import (
+	"log/slog"
 	"os"
 	"testing"
 
@@ -10,7 +11,6 @@ import (
 	android_mock "github.com/fleetdm/fleet/v4/server/mdm/android/mock"
 	android_service "github.com/fleetdm/fleet/v4/server/mdm/android/service"
 	"github.com/fleetdm/fleet/v4/server/platform/endpointer"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/service/integrationtest"
 	activitiesmod "github.com/fleetdm/fleet/v4/server/service/modules/activities"
@@ -24,12 +24,12 @@ type Suite struct {
 
 func SetUpSuite(t *testing.T, uniqueTestName string) *Suite {
 	ds, redisPool, fleetCfg, fleetSvc, ctx := integrationtest.SetUpMySQLAndRedisAndService(t, uniqueTestName)
-	logger := logging.NewLogfmtLogger(os.Stdout)
+	slogLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	proxy := android_mock.Client{}
 	proxy.InitCommonMocks()
 	activityModule := activitiesmod.NewActivityModule()
 	androidSvc, err := android_service.NewServiceWithClient(
-		logger.SlogLogger(),
+		slogLogger,
 		ds,
 		&proxy,
 		"test-private-key",
@@ -49,7 +49,7 @@ func SetUpSuite(t *testing.T, uniqueTestName string) *Suite {
 		},
 		FleetConfig:    &fleetCfg,
 		Pool:           redisPool,
-		Logger:         logger,
+		Logger:         slogLogger,
 		FeatureRoutes:  []endpointer.HandlerRoutesFunc{android_service.GetRoutes(fleetSvc, androidSvc)},
 		DBConns:        dbConns,
 		ActivityModule: activityModule,
@@ -57,7 +57,7 @@ func SetUpSuite(t *testing.T, uniqueTestName string) *Suite {
 
 	s := &Suite{
 		BaseSuite: integrationtest.BaseSuite{
-			Logger:   logger,
+			Logger:   slogLogger,
 			DS:       ds,
 			FleetCfg: fleetCfg,
 			Users:    users,

server/service/integrationtest/scep_server/scep.go

@@ -3,6 +3,7 @@ package scep_server
 import (
 	"crypto/x509"
 	_ "embed"
+	"log/slog"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
@@ -11,7 +12,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
 	filedepot "github.com/fleetdm/fleet/v4/server/mdm/scep/depot/file"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/gorilla/mux"
 )
 
@@ -63,9 +63,9 @@ func StartTestSCEPServer(t *testing.T) *httptest.Server {
 		if err != nil {
 			t.Fatal(err)
 		}
-		logger := logging.NewNopLogger()
+		logger := slog.New(slog.DiscardHandler)
 		e := scepserver.MakeServerEndpoints(svc)
-		scepHandler := scepserver.MakeHTTPHandler(e, svc, logger.SlogLogger())
+		scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
 		r := mux.NewRouter()
 		r.Handle("/scep", scepHandler)
 		server = httptest.NewServer(r)

server/service/integrationtest/suite.go

@@ -2,6 +2,7 @@ package integrationtest
 
 import (
 	"context"
+	"log/slog"
 	"net/http/httptest"
 	"testing"
 
@@ -9,7 +10,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/platform/mysql/testing_utils"
 	"github.com/fleetdm/fleet/v4/server/service"
 	"github.com/fleetdm/fleet/v4/server/test"
@@ -17,7 +17,7 @@ import (
 )
 
 type BaseSuite struct {
-	Logger   *logging.Logger
+	Logger   *slog.Logger
 	FleetCfg config.FleetConfig
 	Server   *httptest.Server
 	DS       *mysql.Datastore

server/service/mdm_scep.go

@@ -9,9 +9,8 @@ import (
 	"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/mdm/assets"
+	"github.com/fleetdm/fleet/v4/server/mdm/scep/kitlogadapter"
 	scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
-
 	"github.com/smallstep/scep"
 )
 
@@ -46,7 +45,7 @@ func (svc *service) PKIOperation(ctx context.Context, data []byte) ([]byte, erro
 	if len(data) == 0 {
 		return nil, &fleet.BadRequestError{Message: "missing data for PKIOperation"}
 	}
-	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(logging.NewLogger(svc.debugLogger)))
+	msg, err := scep.ParsePKIMessage(data, scep.WithLogger(kitlogadapter.NewLogger(svc.debugLogger)))
 	if err != nil {
 		return nil, err
 	}

server/service/osquery_test.go

@@ -32,7 +32,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/live_query/live_query_mock"
 	"github.com/fleetdm/fleet/v4/server/mock"
 	mockresult "github.com/fleetdm/fleet/v4/server/mock/mockresult"
-	platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/pubsub"
 	"github.com/fleetdm/fleet/v4/server/service/async"
@@ -601,7 +600,7 @@ func TestSubmitStatusLogs(t *testing.T) {
 
 func TestSubmitResultLogsToLogDestination(t *testing.T) {
 	ds := new(mock.Store)
-	svc, ctx := newTestService(t, ds, nil, nil, &TestServerOpts{Logger: platformlogging.NewJSONLogger(os.Stdout)})
+	svc, ctx := newTestService(t, ds, nil, nil, &TestServerOpts{Logger: slog.New(slog.NewJSONHandler(os.Stdout, nil))})
 
 	ds.AppConfigFunc = func(ctx context.Context) (*fleet.AppConfig, error) {
 		return &fleet.AppConfig{}, nil
@@ -3099,7 +3098,7 @@ func TestGetHostIdentifier(t *testing.T) {
 
 func TestDistributedQueriesLogsManyErrors(t *testing.T) {
 	buf := new(bytes.Buffer)
-	logger := platformlogging.NewJSONLogger(buf)
+	logger := slog.New(slog.NewJSONHandler(buf, nil))
 	ds := new(mock.Store)
 	svc, ctx := newTestService(t, ds, nil, nil)
 
@@ -3141,7 +3140,7 @@ func TestDistributedQueriesLogsManyErrors(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	lCtx.Log(ctx, logger.SlogLogger())
+	lCtx.Log(ctx, logger)
 
 	logs := buf.String()
 	parts := strings.Split(strings.TrimSpace(logs), "\n")
@@ -3894,7 +3893,7 @@ func TestLiveQueriesFailing(t *testing.T) {
 	lq := live_query_mock.New(t)
 	cfg := config.TestConfig()
 	buf := new(bytes.Buffer)
-	logger := platformlogging.NewLogfmtLogger(buf)
+	logger := slog.New(slog.NewTextHandler(buf, nil))
 	svc, ctx := newTestServiceWithConfig(t, ds, cfg, nil, lq, &TestServerOpts{
 		Logger: logger,
 	})
@@ -3938,7 +3937,7 @@ func TestLiveQueriesFailing(t *testing.T) {
 
 	logs, err := io.ReadAll(buf)
 	require.NoError(t, err)
-	require.Contains(t, string(logs), "level=error")
+	require.Contains(t, string(logs), "level=ERROR")
 	require.Contains(t, string(logs), "failed to get queries for host")
 }
 

server/service/testing_client.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"mime/multipart"
 	"net/http"
 	"net/http/cookiejar"
@@ -25,7 +26,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/redis/redistest"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/live_query/live_query_mock"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	common_mysql "github.com/fleetdm/fleet/v4/server/platform/mysql"
 	"github.com/fleetdm/fleet/v4/server/pubsub"
 	"github.com/fleetdm/fleet/v4/server/service/contract"
@@ -100,7 +100,7 @@ func (ts *withServer) SetupSuite(dbName string) {
 		DBConns:     ts.dbConns,
 	}
 	if os.Getenv("FLEET_INTEGRATION_TESTS_DISABLE_LOG") != "" {
-		opts.Logger = logging.NewNopLogger()
+		opts.Logger = slog.New(slog.DiscardHandler)
 	}
 	users, server := RunServerForTestsWithDS(ts.s.T(), ts.ds, opts)
 	ts.server = server

server/service/testing_utils.go

@@ -7,6 +7,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -51,7 +52,6 @@ import (
 	fleet_mock "github.com/fleetdm/fleet/v4/server/mock"
 	nanodep_mock "github.com/fleetdm/fleet/v4/server/mock/nanodep"
 	"github.com/fleetdm/fleet/v4/server/platform/endpointer"
-	platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
 	common_mysql "github.com/fleetdm/fleet/v4/server/platform/mysql"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/service/async"
@@ -77,8 +77,8 @@ func newTestService(t *testing.T, ds fleet.Datastore, rs fleet.QueryResultStore,
 
 func newTestServiceWithConfig(t *testing.T, ds fleet.Datastore, fleetConfig config.FleetConfig, rs fleet.QueryResultStore, lq fleet.LiveQueryStore, opts ...*TestServerOpts) (fleet.Service, context.Context) {
 	lic := &fleet.LicenseInfo{Tier: fleet.TierFree}
-	logger := platformlogging.NewNopLogger()
-	writer, err := logging.NewFilesystemLogWriter(t.Context(), fleetConfig.Filesystem.StatusLogFile, logger.SlogLogger(), fleetConfig.Filesystem.EnableLogRotation,
+	logger := slog.New(slog.DiscardHandler)
+	writer, err := logging.NewFilesystemLogWriter(t.Context(), fleetConfig.Filesystem.StatusLogFile, logger, fleetConfig.Filesystem.EnableLogRotation,
 		fleetConfig.Filesystem.EnableLogCompression, 500, 28, 3)
 	require.NoError(t, err)
 
@@ -90,9 +90,9 @@ func newTestServiceWithConfig(t *testing.T, ds fleet.Datastore, fleetConfig conf
 		depStorage                      nanodep_storage.AllDEPStorage = &nanodep_mock.Storage{}
 		mailer                          fleet.MailService             = &mockMailService{SendEmailFn: func(e fleet.Email) error { return nil }}
 		c                               clock.Clock                   = clock.C
-		scepConfigService                                             = eeservice.NewSCEPConfigService(logger.SlogLogger(), nil)
-		digiCertService                                               = digicert.NewService(digicert.WithLogger(logger.SlogLogger()))
-		estCAService                                                  = est.NewService(est.WithLogger(logger.SlogLogger()))
+		scepConfigService                                             = eeservice.NewSCEPConfigService(logger, nil)
+		digiCertService                                               = digicert.NewService(digicert.WithLogger(logger))
+		estCAService                                                  = est.NewService(est.WithLogger(logger))
 		conditionalAccessMicrosoftProxy ConditionalAccessMicrosoftProxy
 
 		mdmStorage             fleet.MDMAppleStore
@@ -177,7 +177,7 @@ func newTestServiceWithConfig(t *testing.T, ds fleet.Datastore, fleetConfig conf
 	var eh *errorstore.Handler
 	if len(opts) > 0 {
 		if opts[0].Pool != nil {
-			eh = errorstore.NewHandler(ctx, opts[0].Pool, logger.SlogLogger(), time.Minute*10)
+			eh = errorstore.NewHandler(ctx, opts[0].Pool, logger, time.Minute*10)
 			ctx = ctxerr.NewContext(ctx, eh)
 		}
 		if opts[0].StartCronSchedules != nil {
@@ -218,7 +218,7 @@ func newTestServiceWithConfig(t *testing.T, ds fleet.Datastore, fleetConfig conf
 		ds,
 		task,
 		rs,
-		logger.SlogLogger(),
+		logger,
 		osqlogger,
 		fleetConfig,
 		mailer,
@@ -262,7 +262,7 @@ func newTestServiceWithConfig(t *testing.T, ds fleet.Datastore, fleetConfig conf
 		svc, err = eeservice.NewService(
 			svc,
 			ds,
-			logger.SlogLogger(),
+			logger,
 			fleetConfig,
 			mailer,
 			c,
@@ -399,7 +399,7 @@ type ConditionalAccess struct {
 }
 
 type TestServerOpts struct {
-	Logger                          *platformlogging.Logger
+	Logger                          *slog.Logger
 	License                         *fleet.LicenseInfo
 	SkipCreateTestUsers             bool
 	Rs                              fleet.QueryResultStore
@@ -470,7 +470,7 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 	if len(opts) == 0 || (len(opts) > 0 && !opts[0].SkipCreateTestUsers) {
 		users = createTestUsers(t, ds)
 	}
-	logger := platformlogging.NewLogfmtLogger(os.Stdout)
+	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
 	if len(opts) > 0 && opts[0].Logger != nil {
 		logger = opts[0].Logger
 	}
@@ -485,12 +485,11 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 		require.NoError(t, err)
 		activityAuthorizer := authz.NewAuthorizerAdapter(legacyAuthorizer)
 		activityACLAdapter := activityacl.NewFleetServiceAdapter(svc)
-		slogLogger := logger.SlogLogger()
 		activitySvc, activityRoutesFn := activity_bootstrap.New(
 			opts[0].DBConns,
 			activityAuthorizer,
 			activityACLAdapter,
-			slogLogger,
+			logger,
 		)
 		svc.SetActivityService(activitySvc)
 		if opts[0].ActivityModule != nil {
@@ -527,19 +526,19 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 		commander := apple_mdm.NewMDMAppleCommander(mdmStorage, mdmPusher)
 		if mdmStorage != nil && scepStorage != nil {
 			vppInstaller := svc.(fleet.AppleMDMVPPInstaller)
-			checkInAndCommand := NewMDMAppleCheckinAndCommandService(ds, commander, vppInstaller, opts[0].License.IsPremium(), logger.SlogLogger(), redis_key_value.New(redisPool), svc.NewActivity)
-			checkInAndCommand.RegisterResultsHandler("InstalledApplicationList", NewInstalledApplicationListResultsHandler(ds, commander, logger.SlogLogger(), cfg.Server.VPPVerifyTimeout, cfg.Server.VPPVerifyRequestDelay, svc.NewActivity))
-			checkInAndCommand.RegisterResultsHandler(fleet.DeviceLocationCmdName, NewDeviceLocationResultsHandler(ds, commander, logger.SlogLogger()))
+			checkInAndCommand := NewMDMAppleCheckinAndCommandService(ds, commander, vppInstaller, opts[0].License.IsPremium(), logger, redis_key_value.New(redisPool), svc.NewActivity)
+			checkInAndCommand.RegisterResultsHandler("InstalledApplicationList", NewInstalledApplicationListResultsHandler(ds, commander, logger, cfg.Server.VPPVerifyTimeout, cfg.Server.VPPVerifyRequestDelay, svc.NewActivity))
+			checkInAndCommand.RegisterResultsHandler(fleet.DeviceLocationCmdName, NewDeviceLocationResultsHandler(ds, commander, logger))
 			err := RegisterAppleMDMProtocolServices(
 				rootMux,
 				cfg.MDM,
 				mdmStorage,
 				scepStorage,
-				logger.SlogLogger(),
+				logger,
 				checkInAndCommand,
 				&MDMAppleDDMService{
 					ds:     ds,
-					logger: logger.SlogLogger(),
+					logger: logger,
 				},
 				commander,
 				"https://test-url.com",
@@ -559,7 +558,7 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 			err := RegisterSCEPProxy(
 				rootMux,
 				ds,
-				logger.SlogLogger(),
+				logger,
 				timeout,
 				&cfg,
 			)
@@ -568,7 +567,7 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 	}
 
 	if len(opts) > 0 && opts[0].WithDEPWebview {
-		frontendHandler := WithMDMEnrollmentMiddleware(svc, logger.SlogLogger(), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		frontendHandler := WithMDMEnrollmentMiddleware(svc, logger, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// do nothing and return 200
 			w.WriteHeader(http.StatusOK)
 		}))
@@ -583,32 +582,32 @@ func RunServerForTestsWithServiceWithDS(t *testing.T, ctx context.Context, ds fl
 	extra = append(extra, WithLoginRateLimit(throttled.PerMin(1000)))
 
 	if len(opts) > 0 && opts[0].HostIdentity != nil {
-		require.NoError(t, hostidentity.RegisterSCEP(rootMux, opts[0].HostIdentity.SCEPStorage, ds, logger.SlogLogger(), &cfg))
+		require.NoError(t, hostidentity.RegisterSCEP(rootMux, opts[0].HostIdentity.SCEPStorage, ds, logger, &cfg))
 		var httpSigVerifier func(http.Handler) http.Handler
 		httpSigVerifier, err := httpsig.Middleware(ds, opts[0].HostIdentity.RequireHTTPMessageSignature,
-			logger.With("component", "http-sig-verifier").SlogLogger())
+			logger.With("component", "http-sig-verifier"))
 		require.NoError(t, err)
 		extra = append(extra, WithHTTPSigVerifier(httpSigVerifier))
 	}
 
 	if len(opts) > 0 && opts[0].ConditionalAccess != nil {
-		require.NoError(t, condaccess.RegisterSCEP(ctx, rootMux, opts[0].ConditionalAccess.SCEPStorage, ds, logger.SlogLogger(), &cfg))
-		require.NoError(t, condaccess.RegisterIdP(rootMux, ds, logger.SlogLogger(), &cfg))
+		require.NoError(t, condaccess.RegisterSCEP(ctx, rootMux, opts[0].ConditionalAccess.SCEPStorage, ds, logger, &cfg))
+		require.NoError(t, condaccess.RegisterIdP(rootMux, ds, logger, &cfg))
 	}
 	var carveStore fleet.CarveStore = ds // In tests, we use MySQL as storage for carves.
-	apiHandler := MakeHandler(svc, cfg, logger.SlogLogger(), limitStore, redisPool, carveStore, featureRoutes, extra...)
+	apiHandler := MakeHandler(svc, cfg, logger, limitStore, redisPool, carveStore, featureRoutes, extra...)
 	rootMux.Handle("/api/", apiHandler)
 	var errHandler *errorstore.Handler
 	ctxErrHandler := ctxerr.FromContext(ctx)
 	if ctxErrHandler != nil {
 		errHandler = ctxErrHandler.(*errorstore.Handler)
 	}
-	debugHandler := MakeDebugHandler(svc, cfg, logger.SlogLogger(), errHandler, ds)
+	debugHandler := MakeDebugHandler(svc, cfg, logger, errHandler, ds)
 	rootMux.Handle("/debug/", debugHandler)
-	rootMux.Handle("/enroll", ServeEndUserEnrollOTA(svc, "", ds, logger.SlogLogger()))
+	rootMux.Handle("/enroll", ServeEndUserEnrollOTA(svc, "", ds, logger))
 
 	if len(opts) > 0 && opts[0].EnableSCIM {
-		require.NoError(t, scim.RegisterSCIM(rootMux, ds, svc, logger.SlogLogger(), &cfg))
+		require.NoError(t, scim.RegisterSCIM(rootMux, ds, svc, logger, &cfg))
 		rootMux.Handle("/api/v1/fleet/scim/details", apiHandler)
 		rootMux.Handle("/api/latest/fleet/scim/details", apiHandler)
 	}

server/worker/apple_mdm_test.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"testing"
 	"time"
@@ -16,7 +17,6 @@ import (
 	apple_mdm "github.com/fleetdm/fleet/v4/server/mdm/apple"
 	nanomdm_push "github.com/fleetdm/fleet/v4/server/mdm/nanomdm/push"
 	mock "github.com/fleetdm/fleet/v4/server/mock/mdm"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/fleetdm/fleet/v4/server/test"
 	"github.com/google/uuid"
@@ -98,10 +98,9 @@ func TestAppleMDM(t *testing.T) {
 	mdmStorage, err := ds.NewMDMAppleMDMStorage()
 	require.NoError(t, err)
 
-	// nopLog := logging.NewNopLogger()
+	// nopLog := slog.New(slog.DiscardHandler)
 	// use this to debug/verify details of calls
-	nopLog := logging.NewJSONLogger(os.Stdout)
-	slogLog := nopLog.SlogLogger()
+	slogLog := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
 	testOrgName := "fleet-test"
 
@@ -1426,8 +1425,8 @@ func TestGetSignedURL(t *testing.T) {
 
 	var data []byte
 	buf := bytes.NewBuffer(data)
-	logger := logging.NewLogfmtLogger(buf)
-	a := &AppleMDM{Log: logger.SlogLogger()}
+	logger := slog.New(slog.NewTextHandler(buf, nil))
+	a := &AppleMDM{Log: logger}
 
 	// S3 not configured
 	assert.Empty(t, a.getSignedURL(ctx, meta))

server/worker/db_migrations_test.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"testing"
 	"time"
 
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/fleet"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/test"
 	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/assert"
@@ -23,17 +23,16 @@ func TestDBMigrationsVPPToken(t *testing.T) {
 	// call TruncateTables immediately as a DB migration may have created jobs
 	mysql.TruncateTables(t, ds)
 
-	nopLog := logging.NewNopLogger()
+	nopLog := slog.New(slog.DiscardHandler)
 	// use this to debug/verify details of calls
-	// nopLog := logging.NewJSONLogger(os.Stdout)
+	// nopLog = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
 	// create and register the worker
-	slogLog := nopLog.SlogLogger()
 	processor := &DBMigration{
 		Datastore: ds,
-		Log:       slogLog,
+		Log:       nopLog,
 	}
-	w := NewWorker(ds, slogLog)
+	w := NewWorker(ds, nopLog)
 	w.Register(processor)
 
 	// create the migrated token and enqueue the job

server/worker/macos_setup_assistant_test.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -17,7 +18,6 @@ import (
 	apple_mdm "github.com/fleetdm/fleet/v4/server/mdm/apple"
 	nanodep_client "github.com/fleetdm/fleet/v4/server/mdm/nanodep/client"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanodep/godep"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/stretchr/testify/require"
 )
@@ -73,14 +73,14 @@ func TestMacosSetupAssistant(t *testing.T) {
 	err = ds.AddHostsToTeam(ctx, fleet.NewAddHostsToTeamParams(&tm2.ID, []uint{hosts[4].ID, hosts[5].ID}))
 	require.NoError(t, err)
 
-	logger := logging.NewNopLogger()
+	logger := slog.New(slog.DiscardHandler)
 	depStorage, err := ds.NewMDMAppleDEPStorage()
 	require.NoError(t, err)
 	macosJob := &MacosSetupAssistant{
 		Datastore:  ds,
-		Log:        logger.SlogLogger(),
-		DEPService: apple_mdm.NewDEPService(ds, depStorage, logger.SlogLogger()),
-		DEPClient:  apple_mdm.NewDEPClient(depStorage, ds, logger.SlogLogger()),
+		Log:        logger,
+		DEPService: apple_mdm.NewDEPService(ds, depStorage, logger),
+		DEPClient:  apple_mdm.NewDEPClient(depStorage, ds, logger),
 	}
 
 	const defaultProfileName = "Fleet default enrollment profile"
@@ -144,7 +144,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	err = depStorage.StoreConfig(ctx, org2Name, &nanodep_client.Config{BaseURL: srv.URL})
 	require.NoError(t, err)
 
-	w := NewWorker(ds, logger.SlogLogger())
+	w := NewWorker(ds, logger)
 	w.Register(macosJob)
 
 	runCheckDone := func() {
@@ -166,7 +166,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	start := time.Now().Truncate(time.Second)
 
 	// enqueue a regenerate all and process the jobs
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantUpdateAllProfiles, nil)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantUpdateAllProfiles, nil)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -209,7 +209,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	})
 	require.NoError(t, err)
 	require.NotZero(t, tm1Asst.ID)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantProfileChanged, &tm1.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantProfileChanged, &tm1.ID)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -248,7 +248,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	tm2, err = ds.SaveTeam(ctx, tm2)
 	require.NoError(t, err)
 
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantUpdateProfile, &tm2.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantUpdateProfile, &tm2.ID)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -278,11 +278,11 @@ func TestMacosSetupAssistant(t *testing.T) {
 	require.NotZero(t, tm3Asst.ID)
 	err = ds.DeleteMDMAppleSetupAssistant(ctx, &tm1.ID)
 	require.NoError(t, err)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantProfileChanged, &tm2.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantProfileChanged, &tm2.ID)
 	require.NoError(t, err)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantProfileChanged, &tm3.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantProfileChanged, &tm3.ID)
 	require.NoError(t, err)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantProfileDeleted, &tm1.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantProfileDeleted, &tm1.ID)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -300,7 +300,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	tm2, err = ds.SaveTeam(ctx, tm2)
 	require.NoError(t, err)
 
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantUpdateProfile, &tm2.ID)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantUpdateProfile, &tm2.ID)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -319,9 +319,9 @@ func TestMacosSetupAssistant(t *testing.T) {
 	err = ds.DeleteTeam(ctx, tm2.ID)
 	require.NoError(t, err)
 
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantHostsTransferred, &tm3.ID, "serial-2", "serial-4")
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantHostsTransferred, &tm3.ID, "serial-2", "serial-4")
 	require.NoError(t, err)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantTeamDeleted, nil, "serial-5") // hosts[5] was in team 2
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantTeamDeleted, nil, "serial-5") // hosts[5] was in team 2
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -343,7 +343,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 	require.NoError(t, err)
 	require.NotZero(t, noTmAsst.ID)
 
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantProfileChanged, nil)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantProfileChanged, nil)
 	require.NoError(t, err)
 	runCheckDone()
 
@@ -358,7 +358,7 @@ func TestMacosSetupAssistant(t *testing.T) {
 
 	// check that profiles get re-generated (note that timestamps are not
 	// impacted as the content of the profiles did not change)
-	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger.SlogLogger(), MacosSetupAssistantUpdateAllProfiles, nil)
+	_, err = QueueMacosSetupAssistantJob(ctx, ds, logger, MacosSetupAssistantUpdateAllProfiles, nil)
 	require.NoError(t, err)
 	runCheckDone()
 

server/worker/worker_test.go

@@ -4,13 +4,13 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"log/slog"
 	"testing"
 	"time"
 
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/mock"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/ptr"
 	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/require"
@@ -56,8 +56,8 @@ func TestWorker(t *testing.T) {
 		return job, nil
 	}
 
-	logger := logging.NewNopLogger()
-	w := NewWorker(ds, logger.SlogLogger())
+	logger := slog.New(slog.DiscardHandler)
+	w := NewWorker(ds, logger)
 
 	// register a test job
 	jobCalled := false
@@ -112,8 +112,8 @@ func TestWorkerRetries(t *testing.T) {
 		return job, nil
 	}
 
-	logger := logging.NewNopLogger()
-	w := NewWorker(ds, logger.SlogLogger())
+	logger := slog.New(slog.DiscardHandler)
+	w := NewWorker(ds, logger)
 
 	// register a test job
 	jobCalled := 0
@@ -188,8 +188,8 @@ func TestWorkerMiddleJobFails(t *testing.T) {
 		return job, nil
 	}
 
-	logger := logging.NewNopLogger()
-	w := NewWorker(ds, logger.SlogLogger())
+	logger := slog.New(slog.DiscardHandler)
+	w := NewWorker(ds, logger)
 
 	// register a test job
 	var jobCallCount int
@@ -245,8 +245,8 @@ func TestWorkerWithRealDatastore(t *testing.T) {
 	// call TruncateTables immediately, because a DB migration may create jobs
 	mysql.TruncateTables(t, ds)
 
-	logger := logging.NewNopLogger()
-	w := NewWorker(ds, logger.SlogLogger())
+	logger := slog.New(slog.DiscardHandler)
+	w := NewWorker(ds, logger)
 	w.delayPerRetry = []time.Duration{
 		1: 0,
 		2: 0,

tools/mdm/apple/apnspush/main.go

@@ -18,6 +18,7 @@ import (
 	"encoding/json"
 	"flag"
 	"log"
+	"log/slog"
 	"net/http"
 	"os"
 
@@ -27,7 +28,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanomdm/push/buford"
 	nanomdm_pushsvc "github.com/fleetdm/fleet/v4/server/mdm/nanomdm/push/service"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/fleetdm/fleet/v4/server/service"
 )
 
@@ -63,10 +63,10 @@ func main() {
 		MaxIdleConns:    50,
 		ConnMaxLifetime: 0,
 	}
-	logger := logging.NewLogfmtLogger(os.Stderr)
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
 
 	opts := []mysql.DBOption{
-		mysql.Logger(logger.SlogLogger()),
+		mysql.Logger(logger),
 		mysql.WithFleetConfig(&config.FleetConfig{
 			Server: config.ServerConfig{PrivateKey: *serverPrivateKey},
 		}),
@@ -87,7 +87,7 @@ func main() {
 		})), nil
 	}))
 
-	nanoMDMLogger := service.NewNanoMDMLogger(logger.With("component", "apple-mdm-push").SlogLogger())
+	nanoMDMLogger := service.NewNanoMDMLogger(logger.With("component", "apple-mdm-push"))
 	pusher := nanomdm_pushsvc.New(mdmStorage, mdmStorage, pushProviderFactory, nanoMDMLogger)
 	res, err := pusher.Push(context.Background(), hostUUIDs)
 	if err != nil {

tools/mdm/apple/applebmapi/main.go

@@ -12,6 +12,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"log/slog"
 	"os"
 
 	"github.com/WatchBeam/clock"
@@ -19,7 +20,6 @@ import (
 	"github.com/fleetdm/fleet/v4/server/config"
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
 	"github.com/fleetdm/fleet/v4/server/mdm/nanodep/godep"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 )
 
 func main() {
@@ -58,9 +58,9 @@ func main() {
 		MaxIdleConns:    50,
 		ConnMaxLifetime: 0,
 	}
-	logger := logging.NewLogfmtLogger(os.Stderr)
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	opts := []mysql.DBOption{
-		mysql.Logger(logger.SlogLogger()),
+		mysql.Logger(logger),
 		mysql.WithFleetConfig(&config.FleetConfig{
 			Server: config.ServerConfig{
 				PrivateKey: *serverPrivateKey,

tools/mdm/apple/setupexperience/main.go

@@ -13,12 +13,12 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"log/slog"
 	"os"
 
 	"github.com/WatchBeam/clock"
 	"github.com/fleetdm/fleet/v4/server/config"
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
-	"github.com/fleetdm/fleet/v4/server/platform/logging"
 	"github.com/jmoiron/sqlx"
 )
 
@@ -144,9 +144,9 @@ func main() {
 		}
 	}
 
-	logger := logging.NewLogfmtLogger(os.Stderr)
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	opts := []mysql.DBOption{
-		mysql.Logger(logger.SlogLogger()),
+		mysql.Logger(logger),
 		mysql.WithFleetConfig(&config.FleetConfig{
 			Server: config.ServerConfig{
 				PrivateKey: *serverPrivateKey,