Elgato_dark/fleet
1
0
Fork 0
mirror of https://github.com/fleetdm/fleet synced 2026-04-21 13:37:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 91

Replaced all kitlog.Logger instances with the intermediate *logging.Logger (#40425)

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

# Checklist for submitter

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

## Testing

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

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

## Summary by CodeRabbit

* **Refactor**
* Consolidated and standardized internal logging infrastructure across
the application by adopting a unified logging package throughout the
codebase, replacing previous external logging dependencies.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This commit is contained in:
Victor Lyuboslavsky 2026-02-24 18:52:45 -06:00 committed by GitHub
parent 01f61b9384
commit c14bea44de
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
63 changed files with 233 additions and 316 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
cmd/fleet/serve.go
View file

@ -86,8 +86,6 @@ import (
"github.com/getsentry/sentry-go"
"github.com/go-kit/kit/endpoint"
kitprometheus "github.com/go-kit/kit/metrics/prometheus"
"github.com/go-kit/log"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/google/uuid"
grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/recovery"
@ -1960,7 +1958,7 @@ func getTLSConfig(profile string) *tls.Config {
type devSQLInterceptor struct {
sqlmw.NullInterceptor
logger kitlog.Logger
logger *platform_logging.Logger
}
func (in *devSQLInterceptor) ConnQueryContext(ctx context.Context, conn driver.QueryerContext, query string, args []driver.NamedValue) (driver.Rows, error) {
@ -2040,7 +2038,7 @@ func (n nopPusher) Push(context.Context, []string) (map[string]*push.Response, e
return nil, nil
}
func createTestBuckets(config *configpkg.FleetConfig, logger log.Logger) {
func createTestBuckets(config *configpkg.FleetConfig, logger *platform_logging.Logger) {
softwareInstallerStore, err := s3.NewSoftwareInstallerStore(config.S3)
if err != nil {
initFatal(err, "initializing S3 software installer store")

6
cmd/fleetctl/fleetctl/preview.go
View file

@ -27,8 +27,8 @@ 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"
kitlog "github.com/go-kit/log"
"github.com/google/go-github/v37/github"
"github.com/mitchellh/go-ps"
"github.com/rs/zerolog"
@ -373,9 +373,9 @@ Use the stop and reset subcommands to manage the server and dependencies once st
fmt.Println("Loading starter library...")
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
if c.Bool(debugFlagName) {
logger = kitlog.NewLogfmtLogger(os.Stderr)
logger = logging.NewLogfmtLogger(os.Stderr)
}
if err := service.ApplyStarterLibrary(

3
cmd/fleetctl/integrationtest/gitops/gitops_enterprise_integration_test.go
View file

@ -37,7 +37,6 @@ import (
"github.com/fleetdm/fleet/v4/server/service/integrationtest/scep_server"
"github.com/fleetdm/fleet/v4/server/test"
"github.com/go-git/go-git/v5"
kitlog "github.com/go-kit/log"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/stretchr/testify/assert"
@ -111,7 +110,7 @@ func (s *enterpriseIntegrationGitopsTestSuite) SetupSuite() {
SCEPStorage: scepStorage,
Pool: redisPool,
APNSTopic: "com.apple.mgmt.External.10ac3ce5-4668-4e58-b69a-b2b5ce667589",
SCEPConfigService: eeservice.NewSCEPConfigService(kitlog.NewLogfmtLogger(os.Stdout), nil),
SCEPConfigService: eeservice.NewSCEPConfigService(logging.NewLogfmtLogger(os.Stdout), nil),
DigiCertService: digicert.NewService(),
SoftwareTitleIconStore: softwareTitleIconStore,
}

4
cmd/osquery-perf/hostidentity/hostidentity.go
View file

@ -19,7 +19,7 @@ import (
"github.com/fleetdm/fleet/v4/pkg/fleethttpsig"
scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
"github.com/fleetdm/fleet/v4/server/mdm/scep/x509util"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/remitly-oss/httpsig-go"
"github.com/smallstep/scep"
)
@ -107,7 +107,7 @@ func (c *Client) RequestCertificate() error {
// Create SCEP client with no-op logger and 30-second timeout
scepURL := fmt.Sprintf("%s/api/fleet/orbit/host_identity/scep", c.config.ServerAddress)
timeout := 30 * time.Second
scepClient, err := scepclient.New(scepURL, kitlog.NewNopLogger(),
scepClient, err := scepclient.New(scepURL, logging.NewNopLogger(),
scepclient.WithTimeout(&timeout),
scepclient.Insecure(),
)

71
ee/orbit/pkg/scep/scep.go
View file

@ -10,9 +10,12 @@ import (
"crypto/x509/pkix"
"errors"
"fmt"
"log/slog"
"slices"
"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/ptr"
"github.com/rs/zerolog"
"github.com/smallstep/scep"
@ -147,7 +150,7 @@ func NewClient(opts ...Option) (*Client, error) {
func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
// We assume the required fields have already been validated by the NewClient factory.
kitLogger := &zerologAdapter{logger: c.logger}
scepLogger := logging.NewLogger(slog.New(&zerologSlogHandler{logger: c.logger}))
opts := []scepclient.Option{
scepclient.WithTimeout(c.timeout),
scepclient.WithRootCA(c.rootCA),
@ -156,7 +159,7 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
opts = append(opts, scepclient.Insecure())
}
scepClient, err := scepclient.New(c.scepURL, kitLogger, opts...)
scepClient, err := scepclient.New(c.scepURL, scepLogger, opts...)
if err != nil {
return nil, fmt.Errorf("create SCEP client: %w", err)
}
@ -251,7 +254,7 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
},
}
msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(kitLogger))
msg, err := scep.NewCSRRequest(csr, pkiMsgReq, scep.WithLogger(scepLogger))
if err != nil {
return nil, fmt.Errorf("create CSR request: %w", err)
}
@ -261,7 +264,7 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
return nil, fmt.Errorf("do CSR request: %w", err)
}
pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(kitLogger), scep.WithCACerts(msg.Recipients))
pkiMsgResp, err := scep.ParsePKIMessage(respBytes, scep.WithLogger(scepLogger), scep.WithCACerts(msg.Recipients))
if err != nil {
return nil, fmt.Errorf("parse PKIMessage response: %w", err)
}
@ -279,43 +282,47 @@ func (c *Client) FetchCert(ctx context.Context) (*x509.Certificate, error) {
return pkiMsgResp.CertRepMessage.Certificate, nil
}
// zerologAdapter adapts zerolog.Logger to kit/log.Logger
type zerologAdapter struct {
// zerologSlogHandler adapts zerolog.Logger to slog.Handler so it can be used with *logging.Logger.
type zerologSlogHandler struct {
logger zerolog.Logger
attrs []slog.Attr
}
// Log implements the kit/log.Logger interface
func (a *zerologAdapter) Log(keyvals ...interface{}) error {
// Convert key-value pairs to a map
fields := make(map[string]interface{})
for i := 0; i < len(keyvals); i += 2 {
if i+1 < len(keyvals) {
key, ok := keyvals[i].(string)
if ok {
fields[key] = keyvals[i+1]
}
}
}
func (h *zerologSlogHandler) Enabled(_ context.Context, _ slog.Level) bool {
return true
}
// Extract message if present
msg := ""
if msgVal, ok := fields["msg"]; ok {
if msgStr, ok := msgVal.(string); ok {
msg = msgStr
delete(fields, "msg")
}
func (h *zerologSlogHandler) Handle(_ context.Context, r slog.Record) error {
var event *zerolog.Event
switch r.Level {
case slog.LevelDebug:
event = h.logger.Debug()
case slog.LevelWarn:
event = h.logger.Warn()
case slog.LevelError:
event = h.logger.Error()
default:
event = h.logger.Info()
}
// Log with zerolog
event := a.logger.Info()
for k, v := range fields {
event = event.Interface(k, v)
for _, a := range h.attrs {
event = event.Interface(a.Key, a.Value.Any())
}
event.Msg(msg)
r.Attrs(func(a slog.Attr) bool {
event = event.Interface(a.Key, a.Value.Any())
return true
})
event.Msg(r.Message)
return nil
}
func (h *zerologSlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
return &zerologSlogHandler{logger: h.logger, attrs: slices.Concat(h.attrs, attrs)}
}
func (h *zerologSlogHandler) WithGroup(_ string) slog.Handler {
return h
}
func PublicKeysEqual(a, b crypto.PublicKey) (bool, error) {
derA, err := x509.MarshalPKIXPublicKey(a)
if err != nil {

4
ee/orbit/pkg/scep/scep_test.go
View file

@ -18,8 +18,8 @@ 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"
kitlog "github.com/go-kit/log"
"github.com/gorilla/mux"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
@ -209,7 +209,7 @@ func StartTestSCEPServer(t *testing.T) *httptest.Server {
if err != nil {
t.Fatal(err)
}
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
e := scepserver.MakeServerEndpoints(svc)
scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
r := mux.NewRouter()

9
ee/server/service/condaccess/idp.go
View file

@ -23,7 +23,6 @@ import (
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/service/middleware/log"
"github.com/fleetdm/fleet/v4/server/service/middleware/otel"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/google/uuid"
dsig "github.com/russellhaering/goxmldsig"
@ -105,7 +104,7 @@ func RegisterIdP(
// This function should be used whenever returning StatusInternalServerError to ensure
// consistent error handling across the IdP service.
// Additional key-value pairs can be passed for logging context (e.g., "host_id", hostID).
func handleInternalServerError(ctx context.Context, w http.ResponseWriter, logger kitlog.Logger, msg string, err error, keyvals ...any) {
func handleInternalServerError(ctx context.Context, w http.ResponseWriter, logger *logging.Logger, msg string, err error, keyvals ...any) {
// Build the log keyvals starting with msg and err
logKeyvals := []any{"msg", msg, "err", err}
logKeyvals = append(logKeyvals, keyvals...)
@ -244,7 +243,7 @@ func (s *idpService) serveSSO(w http.ResponseWriter, r *http.Request) {
type statusInterceptingWriter struct {
http.ResponseWriter
ctx context.Context
logger kitlog.Logger
logger *logging.Logger
r *http.Request
redirectURL string
headerWritten bool
@ -302,7 +301,7 @@ func extractNameID(req *saml.IdpAuthnRequest) string {
// device health verification during SAML SSO flow.
type deviceHealthSessionProvider struct {
ds fleet.Datastore
logger kitlog.Logger
logger *logging.Logger
hostID uint
}
@ -490,7 +489,7 @@ func (p *deviceHealthSessionProvider) GetSession(w http.ResponseWriter, r *http.
// Okta service provider metadata to the IdP.
type oktaServiceProviderProvider struct {
ds fleet.Datastore
logger kitlog.Logger
logger *logging.Logger
}
// GetServiceProvider returns the Okta service provider metadata.

5
ee/server/service/condaccess/scep.go
View file

@ -17,7 +17,6 @@ import (
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/go-kit/kit/log"
"github.com/smallstep/scep"
)
@ -112,7 +111,7 @@ var _ scepserver.Service = (*service)(nil)
type service struct {
// The (chainable) CSR signing function
signer scepserver.CSRSignerContext
logger log.Logger
logger *logging.Logger
ds fleet.Datastore
}
@ -212,7 +211,7 @@ func (svc *service) GetNextCACert(_ context.Context) ([]byte, error) {
}
// NewSCEPService creates a new conditional access SCEP service.
func NewSCEPService(ds fleet.Datastore, signer scepserver.CSRSignerContext, logger log.Logger) scepserver.Service {
func NewSCEPService(ds fleet.Datastore, signer scepserver.CSRSignerContext, logger *logging.Logger) scepserver.Service {
return &service{
ds: ds,
signer: signer,

8
ee/server/service/est/est.go
View file

@ -13,14 +13,14 @@ import (
"github.com/fleetdm/fleet/v4/pkg/fleethttp"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/fleet"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
// defaultTimeout is the timeout for requests.
const defaultTimeout = 20 * time.Second
type Service struct {
logger kitlog.Logger
logger *logging.Logger
timeout time.Duration
client *http.Client
}
@ -46,7 +46,7 @@ func WithTimeout(t time.Duration) Opt {
}
// WithLogger sets the logger to use for the service.
func WithLogger(logger kitlog.Logger) Opt {
func WithLogger(logger *logging.Logger) Opt {
return func(s *Service) {
s.logger = logger
}
@ -60,7 +60,7 @@ func (s *Service) populateOpts(opts []Opt) {
s.timeout = defaultTimeout
}
if s.logger == nil {
s.logger = kitlog.NewLogfmtLogger(kitlog.NewSyncWriter(os.Stdout))
s.logger = logging.NewLogfmtLogger(os.Stdout)
}
}

6
ee/server/service/hostidentity/httpsig/httpsig.go
View file

@ -11,14 +11,14 @@ import (
"github.com/fleetdm/fleet/v4/ee/server/service/hostidentity/types"
"github.com/fleetdm/fleet/v4/pkg/fleethttpsig"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
"github.com/remitly-oss/httpsig-go"
)
type HTTPSig struct {
ds fleet.Datastore
logger log.Logger
logger *logging.Logger
}
type KeySpecer struct {
@ -33,7 +33,7 @@ func (k KeySpecer) KeySpec() (httpsig.KeySpec, error) {
// _ ensures that KeySpecer implements the httpsig.KeySpecer interface.
var _ httpsig.KeySpecer = KeySpecer{}
func NewHTTPSig(ds fleet.Datastore, logger log.Logger) *HTTPSig {
func NewHTTPSig(ds fleet.Datastore, logger *logging.Logger) *HTTPSig {
return &HTTPSig{
ds: ds,
logger: logger,

4
ee/server/service/hostidentity/httpsig/middleware.go
View file

@ -10,7 +10,7 @@ import (
"github.com/fleetdm/fleet/v4/ee/server/service/hostidentity/types"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/fleet"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
@ -49,7 +49,7 @@ func FromContext(ctx context.Context) (types.HostIdentityCertificate, bool) {
// to it, and then calls the handler passed as parameter to the MiddlewareFunc.
type MiddlewareFunc func(http.Handler) http.Handler
func Middleware(ds fleet.Datastore, requireSignature bool, logger kitlog.Logger) (MiddlewareFunc, error) {
func Middleware(ds fleet.Datastore, requireSignature bool, logger *logging.Logger) (MiddlewareFunc, error) {
// Initialize HTTP signature verifier
httpSig := NewHTTPSig(ds, logger)
verifier, err := httpSig.Verifier()

5
ee/server/service/hostidentity/scep.go
View file

@ -27,7 +27,6 @@ import (
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/go-kit/kit/log"
"github.com/go-kit/log/level"
"github.com/smallstep/scep"
)
@ -224,7 +223,7 @@ type service struct {
// issuance, RA proxying, etc.
signer scepserver.CSRSignerContext
logger log.Logger
logger *logging.Logger
ds fleet.Datastore
}
@ -322,7 +321,7 @@ func (svc *service) GetNextCACert(_ context.Context) ([]byte, error) {
}
// NewSCEPService creates a new scep service
func NewSCEPService(ds fleet.Datastore, signer scepserver.CSRSignerContext, logger log.Logger) scepserver.Service {
func NewSCEPService(ds fleet.Datastore, signer scepserver.CSRSignerContext, logger *logging.Logger) scepserver.Service {
return &service{
ds: ds,
signer: signer,

10
ee/server/service/scep_proxy.go
View file

@ -21,9 +21,9 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
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/go-kit/kit/log/level"
"github.com/go-kit/log"
"github.com/google/uuid"
"golang.org/x/net/html/charset"
"golang.org/x/text/encoding/unicode"
@ -200,12 +200,12 @@ func (a *certificateTemplateForHostAdapter) GetProfileUUID() string {
type scepProxyService struct {
ds fleet.Datastore
// info logging is implemented in the service middleware layer.
debugLogger log.Logger
debugLogger *logging.Logger
Timeout *time.Duration
}
// NewSCEPProxyService creates a new scep proxy service
func NewSCEPProxyService(ds fleet.Datastore, logger log.Logger, timeout *time.Duration) scepserver.ServiceWithIdentifier {
func NewSCEPProxyService(ds fleet.Datastore, logger *logging.Logger, timeout *time.Duration) scepserver.ServiceWithIdentifier {
if timeout == nil {
timeout = ptr.Duration(30 * time.Second)
}
@ -485,12 +485,12 @@ func (svc *scepProxyService) handleFleetChallenge(ctx context.Context, fleetChal
}
type SCEPConfigService struct {
logger log.Logger
logger *logging.Logger
// Timeout is the timeout for SCEP requests.
Timeout *time.Duration
}
func NewSCEPConfigService(logger log.Logger, timeout *time.Duration) fleet.SCEPConfigService {
func NewSCEPConfigService(logger *logging.Logger, timeout *time.Duration) fleet.SCEPConfigService {
if timeout == nil {
timeout = ptr.Duration(30 * time.Second)
}

8
ee/server/service/scep_proxy_test.go
View file

@ -14,8 +14,8 @@ import (
"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"
kitlog "github.com/go-kit/log"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -45,7 +45,7 @@ func TestValidateNDESSCEPAdminURL(t *testing.T) {
}
returnStatus = http.StatusNotFound
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
svc := NewSCEPConfigService(logger, nil)
err := svc.ValidateNDESSCEPAdminURL(context.Background(), proxy)
assert.ErrorContains(t, err, "unexpected status code")
@ -185,7 +185,7 @@ func TestValidateSCEPURL(t *testing.T) {
proxy := fleet.NDESSCEPProxyCA{
URL: srv.URL + "/scep",
}
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
svc := NewSCEPConfigService(logger, nil)
err := svc.ValidateSCEPURL(context.Background(), proxy.URL)
assert.NoError(t, err)
@ -199,7 +199,7 @@ func TestValidateIdentifier(t *testing.T) {
t.Parallel()
ctx := context.Background()
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
// Helper to create a scepProxyService with a mock datastore
newTestService := func(ds *mock.DataStore) *scepProxyService {

6
ee/server/service/software_installers.go
View file

@ -28,10 +28,10 @@ import (
"github.com/fleetdm/fleet/v4/server/mdm/apple/vpp"
maintained_apps "github.com/fleetdm/fleet/v4/server/mdm/maintainedapps"
"github.com/fleetdm/fleet/v4/server/mdm/nanomdm/mdm"
"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/worker"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/google/uuid"
"golang.org/x/sync/errgroup"
@ -2863,7 +2863,7 @@ func UpgradeCodeMigration(
ctx context.Context,
ds fleet.Datastore,
softwareInstallStore fleet.SoftwareInstallerStore,
logger kitlog.Logger,
logger *logging.Logger,
) error {
// Find MSI installers without upgrade_code
idMap, err := ds.GetMSIInstallersWithoutUpgradeCode(ctx)
@ -2935,7 +2935,7 @@ func UninstallSoftwareMigration(
ctx context.Context,
ds fleet.Datastore,
softwareInstallStore fleet.SoftwareInstallerStore,
logger kitlog.Logger,
logger *logging.Logger,
) error {
// Find software installers that should have their uninstall script populated
idMap, err := ds.GetSoftwareInstallersPendingUninstallScriptPopulation(ctx)

4
ee/server/service/testing_utils.go
View file

@ -16,7 +16,7 @@ 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"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/gorilla/mux"
"github.com/stretchr/testify/require"
)
@ -59,7 +59,7 @@ func NewTestSCEPServer(t *testing.T) *httptest.Server {
if err != nil {
t.Fatal(err)
}
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
e := scepserver.MakeServerEndpoints(svc)
scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
r := mux.NewRouter()

11
pkg/mdm/mdmtest/apple.go
View file

@ -31,9 +31,8 @@ import (
"github.com/fleetdm/fleet/v4/server/mdm/scep/depot"
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/go-kit/log"
kitlog "github.com/go-kit/log"
"github.com/google/uuid"
"github.com/micromdm/plist"
"github.com/smallstep/pkcs7"
@ -682,11 +681,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 log.Logger
var logger *logging.Logger
if c.debug {
logger = kitlog.NewJSONLogger(os.Stdout)
logger = logging.NewJSONLogger(os.Stdout)
} else {
logger = kitlog.NewNopLogger()
logger = logging.NewNopLogger()
}
client, err := newSCEPClient(url, logger)
if err != nil {
@ -1297,7 +1296,7 @@ type scepClient interface {
func newSCEPClient(
serverURL string,
logger log.Logger,
logger *logging.Logger,
) (scepClient, error) {
endpoints, err := makeClientSCEPEndpoints(serverURL)
if err != nil {

6
server/logging/filesystem.go
View file

@ -14,7 +14,7 @@ import (
"github.com/fleetdm/fleet/v4/pkg/secure"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
lumberjack "gopkg.in/natefinch/lumberjack.v2"
)
@ -28,7 +28,7 @@ type filesystemLogWriter struct {
// enableRotation is true
//
// The enableCompression argument is only used when enableRotation is true.
func NewFilesystemLogWriter(path string, appLogger log.Logger, enableRotation, enableCompression bool, maxSize, maxAge, maxBackups int) (*filesystemLogWriter, error) {
func NewFilesystemLogWriter(path string, appLogger *platformlogging.Logger, enableRotation, enableCompression bool, maxSize, maxAge, maxBackups int) (*filesystemLogWriter, error) {
// Fail early if the process does not have the necessary
// permissions to open the file at path.
file, err := openFile(path)
@ -50,7 +50,7 @@ func NewFilesystemLogWriter(path string, appLogger log.Logger, enableRotation, e
MaxAge: maxAge, // days
Compress: enableCompression,
}
appLogger = log.With(appLogger, "component", "filesystem-logger")
appLogger = appLogger.With("component", "filesystem-logger")
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGHUP)
go func() {

10
server/logging/filesystem_test.go
View file

@ -10,7 +10,7 @@ import (
"path/filepath"
"testing"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -20,7 +20,7 @@ func TestFilesystemLogger(t *testing.T) {
tempPath := t.TempDir()
require.NoError(t, os.Chmod(tempPath, 0o755)) // nolint:gosec // G302
fileName := filepath.Join(tempPath, "filesystemLogWriter")
lgr, err := NewFilesystemLogWriter(fileName, log.NewNopLogger(), false, false, 500, 28, 3)
lgr, err := NewFilesystemLogWriter(fileName, platformlogging.NewNopLogger(), false, false, 500, 28, 3)
require.Nil(t, err)
defer os.Remove(fileName)
@ -73,7 +73,7 @@ func TestFilesystemLoggerPermission(t *testing.T) {
{name: "without-rotation", rotation: false},
} {
t.Run(tc.name, func(t *testing.T) {
_, err := NewFilesystemLogWriter(fileName, log.NewNopLogger(), tc.rotation, false, 500, 28, 3)
_, err := NewFilesystemLogWriter(fileName, platformlogging.NewNopLogger(), tc.rotation, false, 500, 28, 3)
require.Error(t, err)
require.True(t, errors.Is(err, fs.ErrPermission), err)
})
@ -83,7 +83,7 @@ func TestFilesystemLoggerPermission(t *testing.T) {
func BenchmarkFilesystemLogger(b *testing.B) {
ctx := context.Background()
fileName := filepath.Join(b.TempDir(), "filesystemLogWriter")
lgr, err := NewFilesystemLogWriter(fileName, log.NewNopLogger(), false, false, 500, 28, 3)
lgr, err := NewFilesystemLogWriter(fileName, platformlogging.NewNopLogger(), false, false, 500, 28, 3)
if err != nil {
b.Fatal("new failed ", err)
}
@ -119,7 +119,7 @@ func BenchmarkLumberjackWithCompression(b *testing.B) {
func benchLumberjack(b *testing.B, compression bool) {
ctx := context.Background()
fileName := filepath.Join(b.TempDir(), "lumberjack")
lgr, err := NewFilesystemLogWriter(fileName, log.NewNopLogger(), true, compression, 500, 28, 3)
lgr, err := NewFilesystemLogWriter(fileName, platformlogging.NewNopLogger(), true, compression, 500, 28, 3)
if err != nil {
b.Fatal("new failed ", err)
}

6
server/logging/firehose.go
View file

@ -15,7 +15,7 @@ import (
"github.com/aws/aws-sdk-go-v2/service/firehose/types"
"github.com/fleetdm/fleet/v4/server/aws_common"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
@ -38,10 +38,10 @@ type FirehoseAPI interface {
type firehoseLogWriter struct {
client FirehoseAPI
stream string
logger log.Logger
logger *platformlogging.Logger
}
func NewFirehoseLogWriter(region, endpointURL, id, secret, stsAssumeRoleArn, stsExternalID, stream string, logger log.Logger) (*firehoseLogWriter, error) {
func NewFirehoseLogWriter(region, endpointURL, id, secret, stsAssumeRoleArn, stsExternalID, stream string, logger *platformlogging.Logger) (*firehoseLogWriter, error) {
var opts []func(*aws_config.LoadOptions) error
// The service endpoint is deprecated, but we still set it

4
server/logging/firehose_test.go
View file

@ -10,7 +10,7 @@ import (
"github.com/aws/aws-sdk-go-v2/service/firehose"
"github.com/aws/aws-sdk-go-v2/service/firehose/types"
"github.com/fleetdm/fleet/v4/server/logging/mock"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/assert"
)
@ -31,7 +31,7 @@ func makeFirehoseWriterWithMock(client FirehoseAPI, stream string) *firehoseLogW
return &firehoseLogWriter{
client: client,
stream: stream,
logger: log.NewNopLogger(),
logger: platformlogging.NewNopLogger(),
}
}

6
server/logging/kinesis.go
View file

@ -17,7 +17,7 @@ import (
smithy "github.com/aws/smithy-go"
"github.com/fleetdm/fleet/v4/server/aws_common"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
@ -40,11 +40,11 @@ type KinesisAPI interface {
type kinesisLogWriter struct {
client KinesisAPI
stream string
logger log.Logger
logger *platformlogging.Logger
rand *rand.Rand
}
func NewKinesisLogWriter(region, endpointURL, id, secret, stsAssumeRoleArn, stsExternalID, stream string, logger log.Logger) (*kinesisLogWriter, error) {
func NewKinesisLogWriter(region, endpointURL, id, secret, stsAssumeRoleArn, stsExternalID, stream string, logger *platformlogging.Logger) (*kinesisLogWriter, error) {
var opts []func(*aws_config.LoadOptions) error
// The service endpoint is deprecated, but we still set it

4
server/logging/kinesis_test.go
View file

@ -13,7 +13,7 @@ import (
"github.com/aws/aws-sdk-go-v2/service/kinesis"
"github.com/aws/aws-sdk-go-v2/service/kinesis/types"
"github.com/fleetdm/fleet/v4/server/logging/mock"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/assert"
)
@ -21,7 +21,7 @@ func makeKinesisWriterWithMock(client KinesisAPI, stream string) *kinesisLogWrit
return &kinesisLogWriter{
client: client,
stream: stream,
logger: log.NewNopLogger(),
logger: platformlogging.NewNopLogger(),
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
}
}

6
server/logging/lambda.go
View file

@ -10,7 +10,7 @@ import (
"github.com/aws/aws-sdk-go-v2/service/lambda"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/fleetdm/fleet/v4/server/aws_common"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
@ -30,10 +30,10 @@ type LambdaAPI interface {
type lambdaLogWriter struct {
client LambdaAPI
functionName string
logger log.Logger
logger *platformlogging.Logger
}
func NewLambdaLogWriter(region, id, secret, stsAssumeRoleArn, stsExternalID, functionName string, logger log.Logger) (*lambdaLogWriter, error) {
func NewLambdaLogWriter(region, id, secret, stsAssumeRoleArn, stsExternalID, functionName string, logger *platformlogging.Logger) (*lambdaLogWriter, error) {
var opts []func(*aws_config.LoadOptions) error
// Only provide static credentials if we have them

4
server/logging/lambda_test.go
View file

@ -9,8 +9,8 @@ import (
"github.com/aws/aws-sdk-go-v2/service/lambda"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/fleetdm/fleet/v4/server/logging/mock"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/test"
"github.com/go-kit/log"
"github.com/stretchr/testify/assert"
tmock "github.com/stretchr/testify/mock"
)
@ -19,7 +19,7 @@ func makeLambdaWriterWithMock(client LambdaAPI, functionName string) *lambdaLogW
return &lambdaLogWriter{
client: client,
functionName: functionName,
logger: log.NewNopLogger(),
logger: platformlogging.NewNopLogger(),
}
}

4
server/logging/logging.go
View file

@ -6,7 +6,7 @@ import (
"time"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
@ -101,7 +101,7 @@ type Config struct {
Nats NatsConfig
}
func NewJSONLogger(name string, config Config, logger log.Logger) (fleet.JSONLogger, error) {
func NewJSONLogger(name string, config Config, logger *platformlogging.Logger) (fleet.JSONLogger, error) {
switch config.Plugin {
case "":
// Allow "" to mean filesystem for backwards compatibility

4
server/logging/nats.go
View file

@ -15,7 +15,7 @@ import (
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/vm"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
"github.com/golang/snappy"
"github.com/klauspost/compress/zstd"
@ -68,7 +68,7 @@ var compressionOk = map[string]bool{
}
// NewNatsLogWriter creates a new NATS log writer.
func NewNatsLogWriter(server, subject, credFile, nkeyFile, tlsClientCrtFile, tlsClientKeyFile, tlsCACrtFile, compression string, jetstream bool, timeout time.Duration, logger log.Logger) (*natsLogWriter, error) {
func NewNatsLogWriter(server, subject, credFile, nkeyFile, tlsClientCrtFile, tlsClientKeyFile, tlsCACrtFile, compression string, jetstream bool, timeout time.Duration, logger *platformlogging.Logger) (*natsLogWriter, error) {
// Ensure the NATS server is set.
if server == "" {
return nil, errors.New("nats server missing")

24
server/logging/nats_test.go
View file

@ -10,7 +10,7 @@ import (
"testing"
"time"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/golang/snappy"
"github.com/klauspost/compress/zstd"
"github.com/nats-io/nats-server/v2/server"
@ -199,7 +199,7 @@ func TestNatsLogWriter(t *testing.T) {
"",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -241,7 +241,7 @@ func TestNatsLogWriter(t *testing.T) {
"",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -294,7 +294,7 @@ func TestNatsLogWriter(t *testing.T) {
"",
true,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -348,7 +348,7 @@ func TestNatsLogWriter(t *testing.T) {
"",
true,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -421,7 +421,7 @@ func TestNatsLogWriter(t *testing.T) {
"gzip",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -466,7 +466,7 @@ func TestNatsLogWriter(t *testing.T) {
"gzip",
true,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -548,7 +548,7 @@ func TestNatsLogWriter(t *testing.T) {
"snappy",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -614,7 +614,7 @@ func TestNatsLogWriter(t *testing.T) {
"zstd",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -659,7 +659,7 @@ func TestNatsLogWriter(t *testing.T) {
"snappy",
true,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -721,7 +721,7 @@ func TestNatsLogWriter(t *testing.T) {
"zstd",
true,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
require.NoError(t, err)
@ -774,7 +774,7 @@ func TestNatsLogWriter(t *testing.T) {
"invalid",
false,
natsTestTimeout,
log.NewNopLogger(),
platformlogging.NewNopLogger(),
)
// Ensure an error is returned.

6
server/logging/pubsub.go
View file

@ -8,13 +8,13 @@ import (
"cloud.google.com/go/pubsub"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
)
type pubSubLogWriter struct {
topic *pubsub.Topic
logger log.Logger
logger *platformlogging.Logger
addAttributes bool
}
@ -24,7 +24,7 @@ type PubSubAttributes struct {
Decorations map[string]string `json:"decorations"`
}
func NewPubSubLogWriter(projectId string, topicName string, addAttributes bool, logger log.Logger) (*pubSubLogWriter, error) {
func NewPubSubLogWriter(projectId string, topicName string, addAttributes bool, logger *platformlogging.Logger) (*pubSubLogWriter, error) {
ctx := context.Background()
client, err := pubsub.NewClient(ctx, projectId)

6
server/logging/webhook.go
View file

@ -8,16 +8,16 @@ import (
"time"
"github.com/fleetdm/fleet/v4/server"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/kit/log/level"
"github.com/go-kit/log"
)
type webhookLogWriter struct {
url string
logger log.Logger
logger *platformlogging.Logger
}
func NewWebhookLogWriter(webhookURL string, logger log.Logger) (*webhookLogWriter, error) {
func NewWebhookLogWriter(webhookURL string, logger *platformlogging.Logger) (*webhookLogWriter, error) {
if webhookURL == "" {
return nil, errors.New("webhook URL missing")
}

6
server/logging/webhook_test.go
View file

@ -8,13 +8,13 @@ import (
"testing"
"time"
"github.com/go-kit/log"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/require"
)
func TestWebhookSubmission(t *testing.T) {
ctx := context.Background()
logger := log.NewNopLogger()
logger := platformlogging.NewNopLogger()
var body struct {
Timestamp time.Time `json:"timestamp"`
Details []json.RawMessage `json:"details"`
@ -42,7 +42,7 @@ func TestWebhookSubmission(t *testing.T) {
func TestWebhookFailure(t *testing.T) {
ctx := context.Background()
logger := log.NewNopLogger()
logger := platformlogging.NewNopLogger()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "bad", http.StatusBadRequest)
}))

3
server/mdm/lifecycle/lifecycle.go
View file

@ -10,7 +10,6 @@ import (
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/ptr"
"github.com/fleetdm/fleet/v4/server/worker"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
)
@ -60,7 +59,7 @@ type HostLifecycle struct {
// NewActivityFunc is the signature type of the service-layer function that can
// create activities and handle the webhook notification and all other
// mechanisms required when creating an activity.
type NewActivityFunc func(ctx context.Context, user *fleet.User, details fleet.ActivityDetails, ds fleet.Datastore, logger kitlog.Logger) error
type NewActivityFunc func(ctx context.Context, user *fleet.User, details fleet.ActivityDetails, ds fleet.Datastore, logger *logging.Logger) error
// New creates a new HostLifecycle struct
func New(ds fleet.Datastore, logger *logging.Logger, newActivityFn NewActivityFunc) *HostLifecycle {

3
server/mdm/lifecycle/lifecycle_test.go
View file

@ -7,11 +7,10 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/mock"
"github.com/fleetdm/fleet/v4/server/platform/logging"
kitlog "github.com/go-kit/log"
"github.com/stretchr/testify/require"
)
func nopNewActivity(ctx context.Context, user *fleet.User, details fleet.ActivityDetails, ds fleet.Datastore, logger kitlog.Logger) error {
func nopNewActivity(ctx context.Context, user *fleet.User, details fleet.ActivityDetails, ds fleet.Datastore, logger *logging.Logger) error {
return nil
}

7
server/mdm/scep/client/client.go
View file

@ -4,9 +4,7 @@ import (
"time"
scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
// Client is a SCEP Client
@ -49,7 +47,7 @@ func WithTimeout(timeout *time.Duration) Option {
// New creates a SCEP Client.
func New(
serverURL string,
logger log.Logger,
logger *logging.Logger,
opts ...Option,
) (Client, error) {
var co clientOpts
@ -67,7 +65,6 @@ func New(
if err != nil {
return nil, err
}
logger = level.Info(logger)
endpoints.GetEndpoint = scepserver.EndpointLoggingMiddleware(logger)(endpoints.GetEndpoint)
endpoints.PostEndpoint = scepserver.EndpointLoggingMiddleware(logger)(endpoints.PostEndpoint)
return endpoints, nil

21
server/mdm/scep/cmd/scepclient/scepclient.go
View file

@ -10,7 +10,6 @@ import (
"flag"
"fmt"
"io/ioutil"
stdlog "log"
"net/url"
"os"
"path/filepath"
@ -18,9 +17,8 @@ import (
"time"
scepclient "github.com/fleetdm/fleet/v4/server/mdm/scep/client"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/smallstep/scep"
)
@ -55,20 +53,15 @@ type runCfg struct {
func run(cfg runCfg) error {
ctx := context.Background()
var logger log.Logger
var logger *logging.Logger
{
if strings.ToLower(cfg.logfmt) == "json" {
logger = log.NewJSONLogger(os.Stderr)
logger = logging.NewLogger(logging.NewSlogLogger(logging.Options{Output: os.Stderr, JSON: true, Debug: cfg.debug}))
} else {
logger = log.NewLogfmtLogger(os.Stderr)
}
stdlog.SetOutput(log.NewStdlibAdapter(logger))
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
if !cfg.debug {
logger = level.NewFilter(logger, level.AllowInfo())
logger = logging.NewLogger(logging.NewSlogLogger(logging.Options{Output: os.Stderr, Debug: cfg.debug}))
}
}
lginfo := level.Info(logger)
lginfo := logger
client, err := scepclient.New(cfg.serverURL, logger)
if err != nil {
@ -131,7 +124,7 @@ func run(cfg runCfg) error {
}
if cfg.debug {
logCerts(level.Debug(logger), caCerts)
logCerts(logger, caCerts)
}
var signerCert *x509.Certificate
@ -219,7 +212,7 @@ func run(cfg runCfg) error {
}
// logCerts logs the count, number, RDN, and fingerprint of certs to logger
func logCerts(logger log.Logger, certs []*x509.Certificate) {
func logCerts(logger *logging.Logger, certs []*x509.Certificate) {
logger.Log("msg", "cacertlist", "count", len(certs))
for i, cert := range certs {
h := fingerprintHashType.New()

21
server/mdm/scep/cmd/scepserver/scepserver.go
View file

@ -21,8 +21,7 @@ import (
scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
"github.com/gorilla/mux"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
// version info
@ -85,21 +84,15 @@ func main() {
httpAddr = ":" + *flPort
}
var logger log.Logger
var logger *logging.Logger
{
if *flLogJSON {
logger = log.NewJSONLogger(os.Stderr)
logger = logging.NewLogger(logging.NewSlogLogger(logging.Options{Output: os.Stderr, JSON: true, Debug: *flDebug, AddSource: true}))
} else {
logger = log.NewLogfmtLogger(os.Stderr)
logger = logging.NewLogger(logging.NewSlogLogger(logging.Options{Output: os.Stderr, Debug: *flDebug, AddSource: true}))
}
if !*flDebug {
logger = level.NewFilter(logger, level.AllowInfo())
}
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
logger = log.With(logger, "caller", log.DefaultCaller)
}
lginfo := level.Info(logger)
lginfo := logger
var err error
var depot scepdepot.Depot // cert storage
@ -161,7 +154,7 @@ func main() {
lginfo.Log("err", err)
os.Exit(1)
}
svc = scepserver.NewLoggingService(log.With(lginfo, "component", "scep_service"), svc)
svc = scepserver.NewLoggingService(lginfo.With("component", "scep_service"), svc)
}
var h http.Handler // http handler
@ -169,7 +162,7 @@ func main() {
e := scepserver.MakeServerEndpoints(svc)
e.GetEndpoint = scepserver.EndpointLoggingMiddleware(lginfo)(e.GetEndpoint)
e.PostEndpoint = scepserver.EndpointLoggingMiddleware(lginfo)(e.PostEndpoint)
scepHandler := scepserver.MakeHTTPHandler(e, svc, log.With(lginfo, "component", "http"))
scepHandler := scepserver.MakeHTTPHandler(e, svc, lginfo.With("component", "http"))
r := mux.NewRouter()
r.Handle("/scep", scepHandler)
h = r

6
server/mdm/scep/csrverifier/executable/csrverifier.go
View file

@ -6,7 +6,7 @@ import (
"os"
"os/exec"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
const (
@ -16,7 +16,7 @@ const (
)
// New creates a executablecsrverifier.ExecutableCSRVerifier.
func New(path string, logger log.Logger) (*ExecutableCSRVerifier, error) {
func New(path string, logger *logging.Logger) (*ExecutableCSRVerifier, error) {
fileInfo, err := os.Stat(path)
if err != nil {
return nil, err
@ -41,7 +41,7 @@ func New(path string, logger log.Logger) (*ExecutableCSRVerifier, error) {
// In any other cases, the CSR is considered invalid.
type ExecutableCSRVerifier struct {
executable string
logger log.Logger
logger *logging.Logger
}
func (v *ExecutableCSRVerifier) Verify(data []byte) (bool, error) {

4
server/mdm/scep/server/endpoint.go
View file

@ -14,9 +14,9 @@ import (
"time"
"github.com/fleetdm/fleet/v4/pkg/fleethttp"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/kit/endpoint"
httptransport "github.com/go-kit/kit/transport/http"
"github.com/go-kit/log"
)
// possible SCEP operations
@ -275,7 +275,7 @@ func (r SCEPResponse) scepOperation() string { return r.operation }
// EndpointLoggingMiddleware returns an endpoint middleware that logs the
// duration of each invocation, and the resulting error, if any.
func EndpointLoggingMiddleware(logger log.Logger) endpoint.Middleware {
func EndpointLoggingMiddleware(logger *logging.Logger) endpoint.Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
var keyvals []interface{}

8
server/mdm/scep/server/service.go
View file

@ -6,7 +6,7 @@ import (
"crypto/x509"
"errors"
"github.com/go-kit/kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/smallstep/scep"
)
@ -88,7 +88,7 @@ type service struct {
signer CSRSignerContext
/// info logging is implemented in the service middleware layer.
debugLogger log.Logger
debugLogger *logging.Logger
}
const DefaultCACaps = "Renewal\nSHA-1\nSHA-256\nAES\nDES3\nSCEPStandard\nPOSTPKIOperation"
@ -146,7 +146,7 @@ type ServiceOption func(*service) error
// WithLogger configures a logger for the SCEP Service.
// By default, a no-op logger is used.
func WithLogger(logger log.Logger) ServiceOption {
func WithLogger(logger *logging.Logger) ServiceOption {
return func(s *service) error {
s.debugLogger = logger
return nil
@ -167,7 +167,7 @@ func NewService(crt *x509.Certificate, key *rsa.PrivateKey, signer CSRSignerCont
crt: crt,
key: key,
signer: signer,
debugLogger: log.NewNopLogger(),
debugLogger: logging.NewNopLogger(),
}
for _, opt := range opts {
if err := opt(s); err != nil {

6
server/mdm/scep/server/service_logging.go
View file

@ -4,16 +4,16 @@ import (
"context"
"time"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
type loggingService struct {
logger log.Logger
logger *logging.Logger
Service
}
// NewLoggingService creates adds logging to the SCEP service
func NewLoggingService(logger log.Logger, s Service) Service {
func NewLoggingService(logger *logging.Logger, s Service) Service {
return &loggingService{logger, s}
}

6
server/mdm/scep/server/transport.go
View file

@ -10,14 +10,14 @@ import (
"net/http"
"net/url"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/kit/transport"
kithttp "github.com/go-kit/kit/transport/http"
kitlog "github.com/go-kit/log"
"github.com/gorilla/mux"
"github.com/groob/finalizer/logutil"
)
func MakeHTTPHandler(e *Endpoints, svc Service, logger kitlog.Logger) http.Handler {
func MakeHTTPHandler(e *Endpoints, svc Service, logger *logging.Logger) http.Handler {
opts := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerFinalizer(logutil.NewHTTPLogger(logger).LoggingFinalizer),
@ -40,7 +40,7 @@ func MakeHTTPHandler(e *Endpoints, svc Service, logger kitlog.Logger) http.Handl
return r
}
func MakeHTTPHandlerWithIdentifier(e *Endpoints, rootPath string, logger kitlog.Logger) http.Handler {
func MakeHTTPHandlerWithIdentifier(e *Endpoints, rootPath string, logger *logging.Logger) http.Handler {
opts := []kithttp.ServerOption{
kithttp.ServerErrorHandler(transport.NewLogErrorHandler(logger)),
kithttp.ServerFinalizer(logutil.NewHTTPLogger(logger).LoggingFinalizer),

5
server/mdm/scep/server/transport_test.go
View file

@ -15,9 +15,8 @@ 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"
kitlog "github.com/go-kit/log"
)
func TestCACaps(t *testing.T) {
@ -240,7 +239,7 @@ func newServer(t *testing.T, opts ...scepserver.ServiceOption) (*httptest.Server
t.Fatal(err)
}
}
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
e := scepserver.MakeServerEndpoints(svc)
scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
r := mux.NewRouter()

5
server/platform/logging/kitlog_adapter.go
View file

@ -3,8 +3,6 @@ package logging
import (
"context"
"log/slog"
kitlog "github.com/go-kit/log"
)
// Logger wraps a slog.Logger to implement the kitlog.Logger interface.
@ -125,6 +123,3 @@ func (a *Logger) InfoContext(ctx context.Context, msg string, keyvals ...any) {
func (a *Logger) DebugContext(ctx context.Context, msg string, keyvals ...any) {
a.logger.DebugContext(ctx, msg, keyvals...)
}
// Ensure Logger implements kitlog.Logger at compile time.
var _ kitlog.Logger = (*Logger)(nil)

68
server/platform/logging/kitlog_adapter_test.go
View file

@ -5,28 +5,19 @@ import (
"log/slog"
"testing"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/fleetdm/fleet/v4/server/platform/logging/testutils"
)
// newTestAdapter creates a kitlog adapter with a TestHandler for capturing records.
func newTestAdapter(t *testing.T) (*testutils.TestHandler, kitlog.Logger) {
t.Helper()
handler := testutils.NewTestHandler()
slogLogger := slog.New(handler)
return handler, NewLogger(slogLogger)
}
func TestKitlogAdapter(t *testing.T) {
t.Parallel()
handler := testutils.NewTestHandler()
adapter := NewLogger(slog.New(handler))
t.Run("basic logging", func(t *testing.T) {
t.Run("basic logging via Log method", func(t *testing.T) {
t.Parallel()
handler, adapter := newTestAdapter(t)
err := adapter.Log("msg", "hello world", "key", "value")
require.NoError(t, err)
@ -41,12 +32,8 @@ func TestKitlogAdapter(t *testing.T) {
t.Run("with context via With", func(t *testing.T) {
t.Parallel()
handler, adapter := newTestAdapter(t)
kitlogAdapter, ok := adapter.(*Logger)
require.True(t, ok, "adapter should be *Logger")
contextLogger := kitlogAdapter.With("component", "test-component")
contextLogger := adapter.With("component", "test-component")
err := contextLogger.Log("msg", "message with context")
require.NoError(t, err)
@ -59,53 +46,6 @@ func TestKitlogAdapter(t *testing.T) {
})
}
func TestKitlogAdapterLevels(t *testing.T) {
t.Parallel()
tests := []struct {
name string
levelFunc func(kitlog.Logger) kitlog.Logger
expectedLevel slog.Level
}{
{
name: "info",
levelFunc: level.Info,
expectedLevel: slog.LevelInfo,
},
{
name: "debug",
levelFunc: level.Debug,
expectedLevel: slog.LevelDebug,
},
{
name: "warn",
levelFunc: level.Warn,
expectedLevel: slog.LevelWarn,
},
{
name: "error",
levelFunc: level.Error,
expectedLevel: slog.LevelError,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
handler, adapter := newTestAdapter(t)
leveledLogger := tc.levelFunc(adapter)
err := leveledLogger.Log("msg", tc.name+" message")
require.NoError(t, err)
record := handler.LastRecord()
require.NotNil(t, record)
assert.Equal(t, tc.name+" message", record.Message)
assert.Equal(t, tc.expectedLevel, record.Level)
})
}
}
func TestKitlogSlogWrappers(t *testing.T) {
t.Parallel()
handler := testutils.NewTestHandler()

3
server/platform/logging/logging.go
View file

@ -25,6 +25,8 @@ type Options struct {
// TracingEnabled enables OpenTelemetry trace correlation.
// When enabled, trace_id and span_id are automatically injected into logs.
TracingEnabled bool
// AddSource adds source file and line number to log entries.
AddSource bool
// OtelLogsEnabled enables exporting logs to an OpenTelemetry collector.
// When enabled, logs are sent to both the primary handler (stderr) and OTEL.
OtelLogsEnabled bool
@ -52,6 +54,7 @@ func NewSlogLogger(opts Options) *slog.Logger {
}
handlerOpts := &slog.HandlerOptions{
AddSource: opts.AddSource,
Level: level,
ReplaceAttr: replaceAttr,
}

4
server/service/activities.go
View file

@ -12,13 +12,13 @@ import (
"github.com/fleetdm/fleet/v4/server"
"github.com/fleetdm/fleet/v4/server/ptr"
kithttp "github.com/go-kit/kit/transport/http"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/contexts/viewer"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/platform/endpointer"
"github.com/fleetdm/fleet/v4/server/platform/logging"
)
////////////////////////////////////////////////////////////////////////////////
@ -37,7 +37,7 @@ func (svc *Service) NewActivity(ctx context.Context, user *fleet.User, activity
return newActivity(ctx, user, activity, svc.ds, svc.logger)
}
func newActivity(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails, ds fleet.Datastore, logger kitlog.Logger) error {
func newActivity(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails, ds fleet.Datastore, logger *logging.Logger) error {
appConfig, err := ds.AppConfig(ctx)
if err != nil {
return ctxerr.Wrap(ctx, err, "get app config")

4
server/service/async/async.go
View file

@ -10,7 +10,7 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/datastore/redis"
"github.com/fleetdm/fleet/v4/server/fleet"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log/level"
redigo "github.com/gomodule/redigo/redis"
)
@ -54,7 +54,7 @@ func NewTask(ds fleet.Datastore, pool fleet.RedisPool, clck clock.Clock, fleetCo
// Collect runs the various collectors as distinct background goroutines if
// async processing is enabled. Each collector will stop processing when ctx
// is done.
func (t *Task) StartCollectors(ctx context.Context, logger kitlog.Logger) {
func (t *Task) StartCollectors(ctx context.Context, logger *logging.Logger) {
collectorErrHandler := func(name string, err error) {
level.Error(logger).Log("err", fmt.Sprintf("%s collector", name), "details", err)
ctxerr.Handle(ctx, err)

4
server/service/devices_url_auth_test.go
View file

@ -7,7 +7,7 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/mock"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/require"
)
@ -20,7 +20,7 @@ func TestAuthenticatedDeviceFallbackAuth(t *testing.T) {
return &fleet.AppConfig{}, nil
}
middleware := authenticatedDevice(svc, log.NewNopLogger(), func(ctx context.Context, request interface{}) (interface{}, error) {
middleware := authenticatedDevice(svc, logging.NewNopLogger(), func(ctx context.Context, request any) (any, error) {
return "success", nil
})

4
server/service/endpoint_campaigns.go
View file

@ -12,8 +12,8 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/viewer"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/websocket"
kitlog "github.com/go-kit/log"
gws "github.com/gorilla/websocket"
"github.com/igm/sockjs-go/v3/sockjs"
)
@ -24,7 +24,7 @@ import (
var reVersion = regexp.MustCompile(`\{fleetversion:\(\?:([^\}\)]+)\)\}`)
func makeStreamDistributedQueryCampaignResultsHandler(config config.ServerConfig, svc fleet.Service, logger kitlog.Logger) func(string) http.Handler {
func makeStreamDistributedQueryCampaignResultsHandler(config config.ServerConfig, svc fleet.Service, logger *logging.Logger) func(string) http.Handler {
opt := sockjs.DefaultOptions
opt.Websocket = true
opt.RawWebsocket = true

16
server/service/endpoint_middleware.go
View file

@ -13,9 +13,9 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/contexts/logging"
"github.com/fleetdm/fleet/v4/server/fleet"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
middleware_log "github.com/fleetdm/fleet/v4/server/service/middleware/log"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
authz_ctx "github.com/fleetdm/fleet/v4/server/contexts/authz"
@ -40,7 +40,7 @@ func extractCertSerialFromHeader(ctx context.Context, r *http.Request) context.C
return certserial.NewContext(ctx, serial)
}
func logJSON(logger log.Logger, v interface{}, key string) {
func logJSON(logger *platformlogging.Logger, v any, key string) {
jsonV, err := json.Marshal(v)
if err != nil {
level.Debug(logger).Log("err", fmt.Errorf("marshaling %s for debug: %w", key, err))
@ -66,7 +66,7 @@ func instrumentHostLogger(ctx context.Context, hostID uint, extras ...interface{
// authenticatedDevice checks the validity of the device auth token
// provided in the request, and attaches the corresponding host to the
// context for the request.
func authenticatedDevice(svc fleet.Service, logger log.Logger, next endpoint.Endpoint) endpoint.Endpoint {
func authenticatedDevice(svc fleet.Service, logger *platformlogging.Logger, next endpoint.Endpoint) endpoint.Endpoint {
authDeviceFunc := func(ctx context.Context, request interface{}) (interface{}, error) {
identifier, err := getDeviceAuthToken(request)
if err != nil {
@ -99,7 +99,7 @@ func authenticatedDevice(svc fleet.Service, logger log.Logger, next endpoint.End
return nil, err
}
hlogger := log.With(logger, "host_id", host.ID)
hlogger := logger.With("host_id", host.ID)
if debug {
logJSON(hlogger, request, "request")
}
@ -137,7 +137,7 @@ func getDeviceAuthToken(r interface{}) (string, error) {
// authenticatedHost wraps an endpoint, checks the validity of the node_key
// provided in the request, and attaches the corresponding osquery host to the
// context for the request
func authenticatedHost(svc fleet.Service, logger log.Logger, next endpoint.Endpoint) endpoint.Endpoint {
func authenticatedHost(svc fleet.Service, logger *platformlogging.Logger, next endpoint.Endpoint) endpoint.Endpoint {
authHostFunc := func(ctx context.Context, request interface{}) (interface{}, error) {
nodeKey, err := getNodeKey(request)
if err != nil {
@ -150,7 +150,7 @@ func authenticatedHost(svc fleet.Service, logger log.Logger, next endpoint.Endpo
return nil, err
}
hlogger := log.With(logger, "host_id", host.ID)
hlogger := logger.With("host_id", host.ID)
if debug {
logJSON(hlogger, request, "request")
}
@ -180,7 +180,7 @@ func authenticatedHost(svc fleet.Service, logger log.Logger, next endpoint.Endpo
func authenticatedOrbitHost(
svc fleet.Service,
logger log.Logger,
logger *platformlogging.Logger,
next endpoint.Endpoint,
orbitNodeKeyGetter func(context.Context, interface{}) (string, error),
) endpoint.Endpoint {
@ -196,7 +196,7 @@ func authenticatedOrbitHost(
return nil, err
}
hlogger := log.With(logger, "host_id", host.ID)
hlogger := logger.With("host_id", host.ID)
if debug {
logJSON(hlogger, request, "request")
}

4
server/service/endpoint_middleware_test.go
View file

@ -9,9 +9,9 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/viewer"
"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/fleetdm/fleet/v4/server/service/middleware/auth"
kitlog "github.com/go-kit/log"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -155,7 +155,7 @@ func TestAuthenticatedHost(t *testing.T) {
endpoint := authenticatedHost(
svc,
kitlog.NewNopLogger(),
logging.NewNopLogger(),
func(ctx context.Context, request interface{}) (interface{}, error) {
host, ok := hostctx.FromContext(ctx)
assert.True(t, ok)

8
server/service/endpoint_setup.go
View file

@ -15,9 +15,9 @@ import (
"github.com/fleetdm/fleet/v4/pkg/spec"
"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/ptr"
"github.com/go-kit/kit/endpoint"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
)
@ -46,7 +46,7 @@ type applyGroupFunc func(context.Context, *spec.Group) error
func (r setupResponse) Error() error { return r.Err }
func makeSetupEndpoint(svc fleet.Service, logger kitlog.Logger) endpoint.Endpoint {
func makeSetupEndpoint(svc fleet.Service, logger *logging.Logger) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
req := request.(setupRequest)
config := &fleet.AppConfig{}
@ -129,7 +129,7 @@ func ApplyStarterLibrary(
ctx context.Context,
serverURL string,
token string,
logger kitlog.Logger,
logger *logging.Logger,
httpClientFactory func(opts ...fleethttp.ClientOpt) *http.Client,
clientFactory func(serverURL string, insecureSkipVerify bool, rootCA, urlPrefix string, options ...ClientOption) (*Client, error),
// For testing only - if provided, this function will be used instead of client.ApplyGroup
@ -292,7 +292,7 @@ func ExtractScriptNames(specs *spec.Group) []string {
}
// DownloadAndUpdateScripts downloads scripts from URLs and updates the specs to reference local files
func DownloadAndUpdateScripts(ctx context.Context, specs *spec.Group, scriptNames []string, tempDir string, logger kitlog.Logger) error {
func DownloadAndUpdateScripts(ctx context.Context, specs *spec.Group, scriptNames []string, tempDir string, logger *logging.Logger) error {
// Create a single HTTP client to be reused for all requests
httpClient := fleethttp.NewClient(fleethttp.WithTimeout(5 * time.Second))

14
server/service/endpoint_setup_test.go
View file

@ -18,7 +18,7 @@ import (
"github.com/fleetdm/fleet/v4/pkg/fleethttp"
"github.com/fleetdm/fleet/v4/pkg/spec"
"github.com/fleetdm/fleet/v4/server/fleet"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -191,7 +191,7 @@ func TestDownloadAndUpdateScripts(t *testing.T) {
}
// Call the actual production function
err = DownloadAndUpdateScripts(context.Background(), specs, tt.scriptNames, tempDir, kitlog.NewNopLogger())
err = DownloadAndUpdateScripts(context.Background(), specs, tt.scriptNames, tempDir, logging.NewNopLogger())
require.NoError(t, err)
// Verify the scripts were downloaded
@ -288,7 +288,7 @@ func TestDownloadAndUpdateScriptsWithInvalidPaths(t *testing.T) {
}
// Call the actual production function
err = DownloadAndUpdateScripts(context.Background(), specs, tt.scriptNames, tempDir, kitlog.NewNopLogger())
err = DownloadAndUpdateScripts(context.Background(), specs, tt.scriptNames, tempDir, logging.NewNopLogger())
require.Error(t, err)
assert.Contains(t, err.Error(), tt.errorMsg)
})
@ -411,7 +411,7 @@ func TestDownloadAndUpdateScriptsTimeout(t *testing.T) {
defer cancel()
// Call the actual production function
err = DownloadAndUpdateScripts(ctx, specs, scriptNames, tempDir, kitlog.NewNopLogger())
err = DownloadAndUpdateScripts(ctx, specs, scriptNames, tempDir, logging.NewNopLogger())
if tt.expectError {
require.Error(t, err)
@ -478,7 +478,7 @@ func TestApplyStarterLibraryWithMockClient(t *testing.T) {
context.Background(),
"https://example.com",
"test-token",
kitlog.NewNopLogger(),
logging.NewNopLogger(),
httpClientFactory,
clientFactory,
mockApplyGroup,
@ -560,7 +560,7 @@ func TestApplyStarterLibraryWithMalformedYAML(t *testing.T) {
context.Background(),
"https://example.com",
"test-token",
kitlog.NewNopLogger(),
logging.NewNopLogger(),
httpClientFactory,
clientFactory,
mockApplyGroup,
@ -666,7 +666,7 @@ func TestApplyStarterLibraryWithFreeLicense(t *testing.T) {
context.Background(),
"https://example.com",
"test-token",
kitlog.NewNopLogger(),
logging.NewNopLogger(),
httpClientFactory,
clientFactory,
mockApplyGroup,

9
server/service/endpoint_utils.go
View file

@ -20,7 +20,6 @@ import (
"github.com/fleetdm/fleet/v4/server/service/middleware/auth"
"github.com/go-kit/kit/endpoint"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/go-kit/log"
"github.com/gorilla/mux"
)
@ -201,7 +200,7 @@ func badRequestf(format string, a ...any) error {
}
}
func newDeviceAuthenticatedEndpointer(svc fleet.Service, logger log.Logger, opts []kithttp.ServerOption, r *mux.Router,
func newDeviceAuthenticatedEndpointer(svc fleet.Service, logger *platform_logging.Logger, opts []kithttp.ServerOption, r *mux.Router,
versions ...string,
) *eu.CommonEndpointer[handlerFunc] {
// Extract certificate serial from X-Client-Cert-Serial header for certificate-based auth
@ -226,7 +225,7 @@ func newDeviceAuthenticatedEndpointer(svc fleet.Service, logger log.Logger, opts
}
}
func newHostAuthenticatedEndpointer(svc fleet.Service, logger log.Logger, opts []kithttp.ServerOption, r *mux.Router,
func newHostAuthenticatedEndpointer(svc fleet.Service, logger *platform_logging.Logger, opts []kithttp.ServerOption, r *mux.Router,
versions ...string,
) *eu.CommonEndpointer[handlerFunc] {
return &eu.CommonEndpointer[handlerFunc]{
@ -246,7 +245,7 @@ func newHostAuthenticatedEndpointer(svc fleet.Service, logger log.Logger, opts [
func androidAuthenticatedEndpointer(
svc fleet.Service,
logger log.Logger,
logger *platform_logging.Logger,
opts []kithttp.ServerOption,
r *mux.Router,
versions ...string,
@ -271,7 +270,7 @@ func androidAuthenticatedEndpointer(
}
}
func newOrbitAuthenticatedEndpointer(svc fleet.Service, logger log.Logger, opts []kithttp.ServerOption, r *mux.Router,
func newOrbitAuthenticatedEndpointer(svc fleet.Service, logger *platform_logging.Logger, opts []kithttp.ServerOption, r *mux.Router,
versions ...string,
) *eu.CommonEndpointer[handlerFunc] {
// Inject the fleet.Capabilities header to the response for Orbit hosts

6
server/service/frontend.go
View file

@ -12,7 +12,7 @@ import (
"github.com/fleetdm/fleet/v4/server/bindata"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/platform/endpointer"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/klauspost/compress/gzhttp"
)
@ -25,7 +25,7 @@ func newBinaryFileSystem(root string) *assetfs.AssetFS {
}
}
func ServeFrontend(urlPrefix string, sandbox bool, logger log.Logger) http.Handler {
func ServeFrontend(urlPrefix string, sandbox bool, logger *logging.Logger) http.Handler {
herr := func(w http.ResponseWriter, err string) {
logger.Log("err", err)
http.Error(w, err, http.StatusInternalServerError)
@ -80,7 +80,7 @@ func ServeEndUserEnrollOTA(
svc fleet.Service,
urlPrefix string,
ds fleet.Datastore,
logger log.Logger,
logger *logging.Logger,
) http.Handler {
herr := func(w http.ResponseWriter, err string) {
logger.Log("err", err)

6
server/service/frontend_test.go
View file

@ -12,7 +12,7 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/mock"
"github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -21,7 +21,7 @@ func TestServeFrontend(t *testing.T) {
if !hasBuildTag("full") {
t.Skip("This test requires running with -tags full")
}
logger := log.NewLogfmtLogger(os.Stdout)
logger := logging.NewLogfmtLogger(os.Stdout)
h := ServeFrontend("", false, logger)
ts := httptest.NewServer(h)
t.Cleanup(func() {
@ -79,7 +79,7 @@ func TestServeEndUserEnrollOTA(t *testing.T) {
appCfg.MDM.EnabledAndConfigured = enabled
appCfg.MDM.AndroidEnabledAndConfigured = enabled
logger := log.NewLogfmtLogger(os.Stdout)
logger := logging.NewLogfmtLogger(os.Stdout)
h := ServeEndUserEnrollOTA(svc, "", ds, logger)
ts := httptest.NewServer(h)
t.Cleanup(func() {

4
server/service/integrationtest/scep_server/scep.go
View file

@ -11,7 +11,7 @@ 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"
kitlog "github.com/go-kit/log"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/gorilla/mux"
)
@ -63,7 +63,7 @@ func StartTestSCEPServer(t *testing.T) *httptest.Server {
if err != nil {
t.Fatal(err)
}
logger := kitlog.NewNopLogger()
logger := logging.NewNopLogger()
e := scepserver.MakeServerEndpoints(svc)
scepHandler := scepserver.MakeHTTPHandler(e, svc, logger)
r := mux.NewRouter()

8
server/service/mdm_scep.go
View file

@ -9,8 +9,8 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/mdm/assets"
scepserver "github.com/fleetdm/fleet/v4/server/mdm/scep/server"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/go-kit/log"
"github.com/smallstep/scep"
)
@ -23,7 +23,7 @@ type service struct {
signer scepserver.CSRSignerContext
/// info logging is implemented in the service middleware layer.
debugLogger log.Logger
debugLogger *logging.Logger
ds fleet.MDMAssetRetriever
}
@ -83,10 +83,10 @@ func (svc *service) GetNextCACert(ctx context.Context) ([]byte, error) {
}
// NewService creates a new scep service
func NewSCEPService(ds fleet.MDMAssetRetriever, signer scepserver.CSRSignerContext, logger log.Logger) scepserver.Service {
func NewSCEPService(ds fleet.MDMAssetRetriever, signer scepserver.CSRSignerContext, logger *logging.Logger) scepserver.Service {
return &service{
signer: signer,
debugLogger: log.NewNopLogger(),
debugLogger: logging.NewNopLogger(),
ds: ds,
}
}

6
server/service/modules/activities/activities.go
View file

@ -13,15 +13,15 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/platform/endpointer"
"github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/ptr"
kithttp "github.com/go-kit/kit/transport/http"
kitlog "github.com/go-kit/log"
"github.com/go-kit/log/level"
)
type activityModule struct {
repo ActivityStore
logger kitlog.Logger
logger *logging.Logger
}
type ActivityModule interface {
@ -35,7 +35,7 @@ type ActivityStore interface {
NewActivity(ctx context.Context, user *fleet.User, activity fleet.ActivityDetails, details []byte, createdAt time.Time) error
}
func NewActivityModule(repo ActivityStore, logger kitlog.Logger) ActivityModule {
func NewActivityModule(repo ActivityStore, logger *logging.Logger) ActivityModule {
return &activityModule{
repo: repo,
logger: logger,

6
server/service/osquery.go
View file

@ -26,13 +26,13 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/license"
"github.com/fleetdm/fleet/v4/server/contexts/logging"
"github.com/fleetdm/fleet/v4/server/fleet"
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/conditional_access_microsoft_proxy"
"github.com/fleetdm/fleet/v4/server/service/contract"
"github.com/fleetdm/fleet/v4/server/service/osquery_utils"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/spf13/cast"
"golang.org/x/exp/slices"
@ -259,7 +259,7 @@ func (svc *Service) serialUpdateHost(host *fleet.Host) {
}
}
func getHostIdentifier(logger log.Logger, identifierOption, providedIdentifier string, details map[string](map[string]string)) string {
func getHostIdentifier(logger *platformlogging.Logger, identifierOption, providedIdentifier string, details map[string](map[string]string)) string {
switch identifierOption {
case "provided":
// Use the host identifier already provided in the request.
@ -1303,7 +1303,7 @@ func processCalendarPolicies(
appConfig *fleet.AppConfig,
host *fleet.Host,
policyResults map[uint]*bool,
logger log.Logger,
logger *platformlogging.Logger,
) error {
if len(appConfig.Integrations.GoogleCalendar) == 0 || host.TeamID == nil {
return nil

4
server/service/service_campaign_test.go
View file

@ -19,10 +19,10 @@ import (
"github.com/fleetdm/fleet/v4/server/fleet"
"github.com/fleetdm/fleet/v4/server/live_query/live_query_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/fleetdm/fleet/v4/server/pubsub"
ws "github.com/fleetdm/fleet/v4/server/websocket"
kitlog "github.com/go-kit/log"
"github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -96,7 +96,7 @@ func TestStreamCampaignResultsClosesReditOnWSClose(t *testing.T) {
_, err := svc.NewDistributedQueryCampaign(viewerCtx, q, nil, fleet.HostTargets{HostIDs: []uint{2}, LabelIDs: []uint{1}})
require.NoError(t, err)
pathHandler := makeStreamDistributedQueryCampaignResultsHandler(config.TestConfig().Server, svc, kitlog.NewNopLogger())
pathHandler := makeStreamDistributedQueryCampaignResultsHandler(config.TestConfig().Server, svc, logging.NewNopLogger())
s := httptest.NewServer(pathHandler("/api/latest/fleet/results/"))
defer s.Close()
// Convert http://127.0.0.1 to ws://127.0.0.1

6
server/service/service_campaigns.go
View file

@ -12,8 +12,8 @@ import (
"github.com/fleetdm/fleet/v4/server/contexts/logging"
"github.com/fleetdm/fleet/v4/server/contexts/viewer"
"github.com/fleetdm/fleet/v4/server/fleet"
platformlogging "github.com/fleetdm/fleet/v4/server/platform/logging"
"github.com/fleetdm/fleet/v4/server/websocket"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/igm/sockjs-go/v3/sockjs"
)
@ -305,7 +305,7 @@ func (svc Service) StreamCampaignResults(ctx context.Context, conn *websocket.Co
// addLiveQueryActivity adds live query activity to the activity feed, including the updated aggregated stats
func (svc Service) addLiveQueryActivity(
ctx context.Context, targetsCount uint, queryID uint, logger log.Logger,
ctx context.Context, targetsCount uint, queryID uint, logger *platformlogging.Logger,
) {
activityData := fleet.ActivityTypeLiveQuery{
TargetsCount: targetsCount,
@ -353,7 +353,7 @@ var (
)
func (svc Service) updateStats(
ctx context.Context, queryID uint, logger log.Logger, tracker *statsTracker, aggregateStats bool,
ctx context.Context, queryID uint, logger *platformlogging.Logger, tracker *statsTracker, aggregateStats bool,
) {
// If we are not saving stats
if tracker == nil || !tracker.saveStats ||

4
server/service/software_installers_test.go
View file

@ -12,9 +12,9 @@ import (
"github.com/fleetdm/fleet/v4/server/datastore/filesystem"
"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/fleetdm/fleet/v4/server/test"
kitlog "github.com/go-kit/log"
"github.com/jmoiron/sqlx"
"github.com/stretchr/testify/require"
)
@ -194,7 +194,7 @@ func TestUpgradeCodeMigration(t *testing.T) {
return nil
}
require.NoError(t, eeservice.UpgradeCodeMigration(ctx, ds, softwareInstallStore, kitlog.NewNopLogger()))
require.NoError(t, eeservice.UpgradeCodeMigration(ctx, ds, softwareInstallStore, logging.NewNopLogger()))
require.True(t, ds.UpdateInstallerUpgradeCodeFuncInvoked)
require.Len(t, updatedInstallerIDs, 2)
}