From 62186cb6bd93c5effc2588392780788f5ff18294 Mon Sep 17 00:00:00 2001 From: Victor Lyuboslavsky <2685025+getvictor@users.noreply.github.com> Date: Sat, 28 Feb 2026 05:52:21 -0600 Subject: [PATCH] Final slog migration PR: test infrastructure + tools + remaining standalone files (#40727) **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 ## 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). --- cmd/fleetctl/fleetctl/preview.go | 8 +- cmd/fleetctl/fleetctl/query_test.go | 6 +- cmd/fleetctl/fleetctl/trigger_test.go | 4 +- .../gitops_enterprise_integration_test.go | 2 +- ee/orbit/pkg/scep/scep.go | 6 +- ee/orbit/pkg/scep/scep_test.go | 6 +- .../condaccess/condaccess_test.go | 7 +- ee/server/integrationtest/condaccess/suite.go | 10 +- .../hostidentity/hostidentity_test.go | 23 ++-- .../hostidentity/scep_rate_limit_test.go | 2 +- .../integrationtest/hostidentity/suite.go | 10 +- ee/server/integrationtest/scim/suite.go | 8 +- ee/server/service/condaccess/scep.go | 4 +- ee/server/service/hostidentity/scep.go | 4 +- ee/server/service/mdm_external_test.go | 8 +- ee/server/service/testing_utils.go | 6 +- go.mod | 2 +- pkg/mdm/mdmtest/apple.go | 19 +-- server/fleet/mdm_test.go | 6 +- server/launcher/server.go | 9 +- .../mdm/android/service/enterprises_test.go | 30 ++--- server/mdm/android/tests/testing_utils.go | 10 +- server/mdm/scep/cmd/scepclient/scepclient.go | 6 +- .../mdm/scep/kitlogadapter/kitlogadapter.go | 88 ++++++++++++ .../scep/kitlogadapter/kitlogadapter_test.go | 58 ++++++++ server/mdm/scep/server/service.go | 4 +- server/mdm/scep/server/transport.go | 6 +- server/platform/logging/kitlog_adapter.go | 125 ------------------ .../platform/logging/kitlog_adapter_test.go | 94 ------------- server/platform/logging/logging.go | 18 --- server/service/integration_enterprise_test.go | 15 +-- server/service/integration_install_test.go | 6 +- .../service/integration_live_queries_test.go | 4 +- server/service/integration_logger_test.go | 3 +- server/service/integration_mdm_ddm_test.go | 32 ++--- .../service/integration_mdm_lifecycle_test.go | 26 ++-- .../service/integration_mdm_profiles_test.go | 6 +- server/service/integration_mdm_test.go | 69 +++++----- server/service/integration_smtp_test.go | 4 +- server/service/integration_sso_test.go | 4 +- .../service/integrationtest/android/suite.go | 10 +- .../integrationtest/scep_server/scep.go | 6 +- server/service/integrationtest/suite.go | 4 +- server/service/mdm_scep.go | 5 +- server/service/osquery_test.go | 11 +- server/service/testing_client.go | 4 +- server/service/testing_utils.go | 55 ++++---- server/worker/apple_mdm_test.go | 11 +- server/worker/db_migrations_test.go | 11 +- server/worker/macos_setup_assistant_test.go | 34 ++--- server/worker/worker_test.go | 18 +-- tools/mdm/apple/apnspush/main.go | 8 +- tools/mdm/apple/applebmapi/main.go | 6 +- tools/mdm/apple/setupexperience/main.go | 6 +- 54 files changed, 424 insertions(+), 523 deletions(-) create mode 100644 server/mdm/scep/kitlogadapter/kitlogadapter.go create mode 100644 server/mdm/scep/kitlogadapter/kitlogadapter_test.go delete mode 100644 server/platform/logging/kitlog_adapter.go delete mode 100644 server/platform/logging/kitlog_adapter_test.go diff --git a/cmd/fleetctl/fleetctl/preview.go b/cmd/fleetctl/fleetctl/preview.go index 7ad7296441..2f7acfcd3f 100644 --- a/cmd/fleetctl/fleetctl/preview.go +++ b/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 diff --git a/cmd/fleetctl/fleetctl/query_test.go b/cmd/fleetctl/fleetctl/query_test.go index a9de730f49..f4c4880421 100644 --- a/cmd/fleetctl/fleetctl/query_test.go +++ b/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{ diff --git a/cmd/fleetctl/fleetctl/trigger_test.go b/cmd/fleetctl/fleetctl/trigger_test.go index 87651d199b..dcff3dbb8e 100644 --- a/cmd/fleetctl/fleetctl/trigger_test.go +++ b/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) { diff --git a/cmd/fleetctl/integrationtest/gitops/gitops_enterprise_integration_test.go b/cmd/fleetctl/integrationtest/gitops/gitops_enterprise_integration_test.go index 968f5eab04..4d225018f3 100644 --- a/cmd/fleetctl/integrationtest/gitops/gitops_enterprise_integration_test.go +++ b/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 diff --git a/ee/orbit/pkg/scep/scep.go b/ee/orbit/pkg/scep/scep.go index 8e8d89b7be..da1cf472af 100644 --- a/ee/orbit/pkg/scep/scep.go +++ b/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 diff --git a/ee/orbit/pkg/scep/scep_test.go b/ee/orbit/pkg/scep/scep_test.go index 9a756f6a07..e20983e9b6 100644 --- a/ee/orbit/pkg/scep/scep_test.go +++ b/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) diff --git a/ee/server/integrationtest/condaccess/condaccess_test.go b/ee/server/integrationtest/condaccess/condaccess_test.go index 89c3ef6c63..ad68058f33 100644 --- a/ee/server/integrationtest/condaccess/condaccess_test.go +++ b/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 diff --git a/ee/server/integrationtest/condaccess/suite.go b/ee/server/integrationtest/condaccess/suite.go index 49dfadeeca..7d1952c9ff 100644 --- a/ee/server/integrationtest/condaccess/suite.go +++ b/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, diff --git a/ee/server/integrationtest/hostidentity/hostidentity_test.go b/ee/server/integrationtest/hostidentity/hostidentity_test.go index 2f956c3312..63fde48d42 100644 --- a/ee/server/integrationtest/hostidentity/hostidentity_test.go +++ b/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 diff --git a/ee/server/integrationtest/hostidentity/scep_rate_limit_test.go b/ee/server/integrationtest/hostidentity/scep_rate_limit_test.go index 2c7576d94b..b7486ce835 100644 --- a/ee/server/integrationtest/hostidentity/scep_rate_limit_test.go +++ b/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 diff --git a/ee/server/integrationtest/hostidentity/suite.go b/ee/server/integrationtest/hostidentity/suite.go index b4cf00c00d..f62fb4a876 100644 --- a/ee/server/integrationtest/hostidentity/suite.go +++ b/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, diff --git a/ee/server/integrationtest/scim/suite.go b/ee/server/integrationtest/scim/suite.go index 79756b192a..701abd0ee9 100644 --- a/ee/server/integrationtest/scim/suite.go +++ b/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, diff --git a/ee/server/service/condaccess/scep.go b/ee/server/service/condaccess/scep.go index 2a2c7a0a39..294b5f18da 100644 --- a/ee/server/service/condaccess/scep.go +++ b/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 } diff --git a/ee/server/service/hostidentity/scep.go b/ee/server/service/hostidentity/scep.go index 4837007e6c..5b9728faa8 100644 --- a/ee/server/service/hostidentity/scep.go +++ b/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 } diff --git a/ee/server/service/mdm_external_test.go b/ee/server/service/mdm_external_test.go index a6339c3f01..7bbee9f5cb 100644 --- a/ee/server/service/mdm_external_test.go +++ b/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, diff --git a/ee/server/service/testing_utils.go b/ee/server/service/testing_utils.go index b811c56b98..6395a35d0f 100644 --- a/ee/server/service/testing_utils.go +++ b/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) diff --git a/go.mod b/go.mod index 814838789d..4a64151dc0 100644 --- a/go.mod +++ b/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 diff --git a/pkg/mdm/mdmtest/apple.go b/pkg/mdm/mdmtest/apple.go index c06b6a4d61..77b9e906b4 100644 --- a/pkg/mdm/mdmtest/apple.go +++ b/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 } diff --git a/server/fleet/mdm_test.go b/server/fleet/mdm_test.go index 5c5eb355a7..26668438a9 100644 --- a/server/fleet/mdm_test.go +++ b/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 diff --git a/server/launcher/server.go b/server/launcher/server.go index 4718da0afe..07bd6055d3 100644 --- a/server/launcher/server.go +++ b/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{ diff --git a/server/mdm/android/service/enterprises_test.go b/server/mdm/android/service/enterprises_test.go index 8d54e87a11..7f816e4fbb 100644 --- a/server/mdm/android/service/enterprises_test.go +++ b/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) diff --git a/server/mdm/android/tests/testing_utils.go b/server/mdm/android/tests/testing_utils.go index 54e92adbfb..ca5e5bb51b 100644 --- a/server/mdm/android/tests/testing_utils.go +++ b/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), ), } diff --git a/server/mdm/scep/cmd/scepclient/scepclient.go b/server/mdm/scep/cmd/scepclient/scepclient.go index eeaa657c82..b840c44eb7 100644 --- a/server/mdm/scep/cmd/scepclient/scepclient.go +++ b/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)) } diff --git a/server/mdm/scep/kitlogadapter/kitlogadapter.go b/server/mdm/scep/kitlogadapter/kitlogadapter.go new file mode 100644 index 0000000000..728ef2501d --- /dev/null +++ b/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 + } +} diff --git a/server/mdm/scep/kitlogadapter/kitlogadapter_test.go b/server/mdm/scep/kitlogadapter/kitlogadapter_test.go new file mode 100644 index 0000000000..ff17fb0049 --- /dev/null +++ b/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) + }) +} diff --git a/server/mdm/scep/server/service.go b/server/mdm/scep/server/service.go index bcb47eb7f7..dce55acbb5 100644 --- a/server/mdm/scep/server/service.go +++ b/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 } diff --git a/server/mdm/scep/server/transport.go b/server/mdm/scep/server/transport.go index 42c6301808..ba40a32bba 100644 --- a/server/mdm/scep/server/transport.go +++ b/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), diff --git a/server/platform/logging/kitlog_adapter.go b/server/platform/logging/kitlog_adapter.go deleted file mode 100644 index a3d8452ae0..0000000000 --- a/server/platform/logging/kitlog_adapter.go +++ /dev/null @@ -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...) -} diff --git a/server/platform/logging/kitlog_adapter_test.go b/server/platform/logging/kitlog_adapter_test.go deleted file mode 100644 index d3be591478..0000000000 --- a/server/platform/logging/kitlog_adapter_test.go +++ /dev/null @@ -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"]) - }) - } -} diff --git a/server/platform/logging/logging.go b/server/platform/logging/logging.go index 78638d857d..d9f4ea4ae0 100644 --- a/server/platform/logging/logging.go +++ b/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})) -} diff --git a/server/service/integration_enterprise_test.go b/server/service/integration_enterprise_test.go index 43aedc2ab4..3eb4d662fb 100644 --- a/server/service/integration_enterprise_test.go +++ b/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 diff --git a/server/service/integration_install_test.go b/server/service/integration_install_test.go index 37369d4155..0b27d3c30f 100644 --- a/server/service/integration_install_test.go +++ b/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 diff --git a/server/service/integration_live_queries_test.go b/server/service/integration_live_queries_test.go index cdc387519f..bcf62aa703 100644 --- a/server/service/integration_live_queries_test.go +++ b/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 diff --git a/server/service/integration_logger_test.go b/server/service/integration_logger_test.go index 052b9a59f7..2045399111 100644 --- a/server/service/integration_logger_test.go +++ b/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{ diff --git a/server/service/integration_mdm_ddm_test.go b/server/service/integration_mdm_ddm_test.go index 0de7d946ae..318b85e84c 100644 --- a/server/service/integration_mdm_ddm_test.go +++ b/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") diff --git a/server/service/integration_mdm_lifecycle_test.go b/server/service/integration_mdm_lifecycle_test.go index e4e91e6e73..52073e3d76 100644 --- a/server/service/integration_mdm_lifecycle_test.go +++ b/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(""))) - 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, "", "", "") // 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) diff --git a/server/service/integration_mdm_profiles_test.go b/server/service/integration_mdm_profiles_test.go index 2766864fe6..e13a80cb2e 100644 --- a/server/service/integration_mdm_profiles_test.go +++ b/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()...) diff --git a/server/service/integration_mdm_test.go b/server/service/integration_mdm_test.go index e707bb4ad3..198e3284fc 100644 --- a/server/service/integration_mdm_test.go +++ b/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) diff --git a/server/service/integration_smtp_test.go b/server/service/integration_smtp_test.go index e8fe7ddeeb..063ef3a295 100644 --- a/server/service/integration_smtp_test.go +++ b/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(), diff --git a/server/service/integration_sso_test.go b/server/service/integration_sso_test.go index 789f5745f9..5c10c1b312 100644 --- a/server/service/integration_sso_test.go +++ b/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 diff --git a/server/service/integrationtest/android/suite.go b/server/service/integrationtest/android/suite.go index e3e7ae92c4..0847af20fd 100644 --- a/server/service/integrationtest/android/suite.go +++ b/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, diff --git a/server/service/integrationtest/scep_server/scep.go b/server/service/integrationtest/scep_server/scep.go index f1b72454b1..e81bf37ae2 100644 --- a/server/service/integrationtest/scep_server/scep.go +++ b/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) diff --git a/server/service/integrationtest/suite.go b/server/service/integrationtest/suite.go index 768289990d..1538a18030 100644 --- a/server/service/integrationtest/suite.go +++ b/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 diff --git a/server/service/mdm_scep.go b/server/service/mdm_scep.go index 492a5c0c2a..d00ea902d8 100644 --- a/server/service/mdm_scep.go +++ b/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 } diff --git a/server/service/osquery_test.go b/server/service/osquery_test.go index 94c1a0ced1..8401fb6a85 100644 --- a/server/service/osquery_test.go +++ b/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") } diff --git a/server/service/testing_client.go b/server/service/testing_client.go index e4eea1a366..e846f381b3 100644 --- a/server/service/testing_client.go +++ b/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 diff --git a/server/service/testing_utils.go b/server/service/testing_utils.go index d4d988ad63..f3796e01fb 100644 --- a/server/service/testing_utils.go +++ b/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) } diff --git a/server/worker/apple_mdm_test.go b/server/worker/apple_mdm_test.go index c48c3ced95..47028d8696 100644 --- a/server/worker/apple_mdm_test.go +++ b/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)) diff --git a/server/worker/db_migrations_test.go b/server/worker/db_migrations_test.go index 405a30e46c..0a0b1d083c 100644 --- a/server/worker/db_migrations_test.go +++ b/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 diff --git a/server/worker/macos_setup_assistant_test.go b/server/worker/macos_setup_assistant_test.go index c9b414b1bb..330f0a338f 100644 --- a/server/worker/macos_setup_assistant_test.go +++ b/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() diff --git a/server/worker/worker_test.go b/server/worker/worker_test.go index cf8916645e..3faac87241 100644 --- a/server/worker/worker_test.go +++ b/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, diff --git a/tools/mdm/apple/apnspush/main.go b/tools/mdm/apple/apnspush/main.go index 24b0d4b726..3f91158097 100644 --- a/tools/mdm/apple/apnspush/main.go +++ b/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 { diff --git a/tools/mdm/apple/applebmapi/main.go b/tools/mdm/apple/applebmapi/main.go index b38505d400..e2ec37928f 100644 --- a/tools/mdm/apple/applebmapi/main.go +++ b/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, diff --git a/tools/mdm/apple/setupexperience/main.go b/tools/mdm/apple/setupexperience/main.go index 460d3d89ff..f6f03838d8 100644 --- a/tools/mdm/apple/setupexperience/main.go +++ b/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,