Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 component.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import ( "os" "strconv" "go.mongodb.org/mongo-driver/bson/primitive" ) const ( CommandFailed = "Command failed" CommandStarted = "Command started" CommandSucceeded = "Command succeeded" ConnectionPoolCreated = "Connection pool created" ConnectionPoolReady = "Connection pool ready" ConnectionPoolCleared = "Connection pool cleared" ConnectionPoolClosed = "Connection pool closed" ConnectionCreated = "Connection created" ConnectionReady = "Connection ready" ConnectionClosed = "Connection closed" ConnectionCheckoutStarted = "Connection checkout started" ConnectionCheckoutFailed = "Connection checkout failed" ConnectionCheckedOut = "Connection checked out" ConnectionCheckedIn = "Connection checked in" ServerSelectionFailed = "Server selection failed" ServerSelectionStarted = "Server selection started" ServerSelectionSucceeded = "Server selection succeeded" ServerSelectionWaiting = "Waiting for suitable server to become available" TopologyClosed = "Stopped topology monitoring" TopologyDescriptionChanged = "Topology description changed" TopologyOpening = "Starting topology monitoring" TopologyServerClosed = "Stopped server monitoring" TopologyServerHeartbeatFailed = "Server heartbeat failed" TopologyServerHeartbeatStarted = "Server heartbeat started" TopologyServerHeartbeatSucceeded = "Server heartbeat succeeded" TopologyServerOpening = "Starting server monitoring" ) const ( KeyAwaited = "awaited" KeyCommand = "command" KeyCommandName = "commandName" KeyDatabaseName = "databaseName" KeyDriverConnectionID = "driverConnectionId" KeyDurationMS = "durationMS" KeyError = "error" KeyFailure = "failure" KeyMaxConnecting = "maxConnecting" KeyMaxIdleTimeMS = "maxIdleTimeMS" KeyMaxPoolSize = "maxPoolSize" KeyMessage = "message" KeyMinPoolSize = "minPoolSize" KeyNewDescription = "newDescription" KeyOperation = "operation" KeyOperationID = "operationId" KeyPreviousDescription = "previousDescription" KeyRemainingTimeMS = "remainingTimeMS" KeyReason = "reason" KeyReply = "reply" KeyRequestID = "requestId" KeySelector = "selector" KeyServerConnectionID = "serverConnectionId" KeyServerHost = "serverHost" KeyServerPort = "serverPort" KeyServiceID = "serviceId" KeyTimestamp = "timestamp" KeyTopologyDescription = "topologyDescription" KeyTopologyID = "topologyId" ) // KeyValues is a list of key-value pairs. type KeyValues []interface{} // Add adds a key-value pair to an instance of a KeyValues list. func (kvs KeyValues) Add(key string, value interface{}) { kvs = append(kvs, key, value) } const ( ReasonConnClosedStale = "Connection became stale because the pool was cleared" ReasonConnClosedIdle = "Connection has been available but unused for longer than the configured max idle time" ReasonConnClosedError = "An error occurred while using the connection" ReasonConnClosedPoolClosed = "Connection pool was closed" ReasonConnCheckoutFailedTimout = "Wait queue timeout elapsed without a connection becoming available" ReasonConnCheckoutFailedError = "An error occurred while trying to establish a new connection" ReasonConnCheckoutFailedPoolClosed = "Connection pool was closed" ) // Component is an enumeration representing the "components" which can be // logged against. A LogLevel can be configured on a per-component basis. type Component int const ( // ComponentAll enables logging for all components. ComponentAll Component = iota // ComponentCommand enables command monitor logging. ComponentCommand // ComponentTopology enables topology logging. ComponentTopology // ComponentServerSelection enables server selection logging. ComponentServerSelection // ComponentConnection enables connection services logging. ComponentConnection ) const ( mongoDBLogAllEnvVar = "MONGODB_LOG_ALL" mongoDBLogCommandEnvVar = "MONGODB_LOG_COMMAND" mongoDBLogTopologyEnvVar = "MONGODB_LOG_TOPOLOGY" mongoDBLogServerSelectionEnvVar = "MONGODB_LOG_SERVER_SELECTION" mongoDBLogConnectionEnvVar = "MONGODB_LOG_CONNECTION" ) var componentEnvVarMap = map[string]Component{ mongoDBLogAllEnvVar: ComponentAll, mongoDBLogCommandEnvVar: ComponentCommand, mongoDBLogTopologyEnvVar: ComponentTopology, mongoDBLogServerSelectionEnvVar: ComponentServerSelection, mongoDBLogConnectionEnvVar: ComponentConnection, } // EnvHasComponentVariables returns true if the environment contains any of the // component environment variables. func EnvHasComponentVariables() bool { for envVar := range componentEnvVarMap { if os.Getenv(envVar) != "" { return true } } return false } // Command is a struct defining common fields that must be included in all // commands. type Command struct { // TODO(GODRIVER-2824): change the DriverConnectionID type to int64. DriverConnectionID uint64 // Driver's ID for the connection Name string // Command name DatabaseName string // Database name Message string // Message associated with the command OperationID int32 // Driver-generated operation ID RequestID int64 // Driver-generated request ID ServerConnectionID int64 // Server's ID for the connection used for the command ServerHost string // Hostname or IP address for the server ServerPort string // Port for the server ServiceID primitive.ObjectID // ID for the command in load balancer mode } // SerializeCommand takes a command and a variable number of key-value pairs and // returns a slice of interface{} that can be passed to the logger for // structured logging. func SerializeCommand(cmd Command, extraKeysAndValues ...interface{}) KeyValues { // Initialize the boilerplate keys and values. keysAndValues := KeyValues{ KeyCommandName, cmd.Name, KeyDatabaseName, cmd.DatabaseName, KeyDriverConnectionID, cmd.DriverConnectionID, KeyMessage, cmd.Message, KeyOperationID, cmd.OperationID, KeyRequestID, cmd.RequestID, KeyServerHost, cmd.ServerHost, } // Add the extra keys and values. for i := 0; i < len(extraKeysAndValues); i += 2 { keysAndValues.Add(extraKeysAndValues[i].(string), extraKeysAndValues[i+1]) } port, err := strconv.ParseInt(cmd.ServerPort, 10, 32) if err == nil { keysAndValues.Add(KeyServerPort, port) } // Add the "serverConnectionId" if it is not nil. if cmd.ServerConnectionID != nil { keysAndValues.Add(KeyServerConnectionID, cmd.ServerConnectionID) } // Add the "serviceId" if it is not nil. if cmd.ServiceID != nil { keysAndValues.Add(KeyServiceID, cmd.ServiceID.Hex()) } return keysAndValues } // Connection contains data that all connection log messages MUST contain. type Connection struct { Message string // Message associated with the connection ServerHost string // Hostname or IP address for the server ServerPort string // Port for the server } // SerializeConnection serializes a Connection message into a slice of keys and // values that can be passed to a logger. func SerializeConnection(conn Connection, extraKeysAndValues ...interface{}) KeyValues { // Initialize the boilerplate keys and values. keysAndValues := KeyValues{ KeyMessage, conn.Message, KeyServerHost, conn.ServerHost, } // Add the optional keys and values. for i := 0; i < len(extraKeysAndValues); i += 2 { keysAndValues.Add(extraKeysAndValues[i].(string), extraKeysAndValues[i+1]) } port, err := strconv.ParseInt(conn.ServerPort, 10, 32) if err == nil { keysAndValues.Add(KeyServerPort, port) } return keysAndValues } // Server contains data that all server messages MAY contain. type Server struct { DriverConnectionID uint64 // Driver's ID for the connection TopologyID primitive.ObjectID // Driver's unique ID for this topology Message string // Message associated with the topology ServerConnectionID int64 // Server's ID for the connection ServerHost string // Hostname or IP address for the server ServerPort string // Port for the server } // SerializeServer serializes a Server message into a slice of keys and // values that can be passed to a logger. func SerializeServer(srv Server, extraKV ...interface{}) KeyValues { // Initialize the boilerplate keys and values. keysAndValues := KeyValues{ KeyDriverConnectionID, srv.DriverConnectionID, KeyMessage, srv.Message, KeyServerHost, srv.ServerHost, KeyTopologyID, srv.TopologyID.Hex(), } if connID := srv.ServerConnectionID; connID != nil { keysAndValues.Add(KeyServerConnectionID, connID) } port, err := strconv.ParseInt(srv.ServerPort, 10, 32) if err == nil { keysAndValues.Add(KeyServerPort, port) } // Add the optional keys and values. for i := 0; i < len(extraKV); i += 2 { keysAndValues.Add(extraKV[i].(string), extraKV[i+1]) } return keysAndValues } // ServerSelection contains data that all server selection messages MUST // contain. type ServerSelection struct { Selector string OperationID int32 Operation string TopologyDescription string } // SerializeServerSelection serializes a Topology message into a slice of keys // and values that can be passed to a logger. func SerializeServerSelection(srvSelection ServerSelection, extraKV ...interface{}) KeyValues { keysAndValues := KeyValues{ KeySelector, srvSelection.Selector, KeyOperation, srvSelection.Operation, KeyTopologyDescription, srvSelection.TopologyDescription, } if srvSelection.OperationID != nil { keysAndValues.Add(KeyOperationID, srvSelection.OperationID) } // Add the optional keys and values. for i := 0; i < len(extraKV); i += 2 { keysAndValues.Add(extraKV[i].(string), extraKV[i+1]) } return keysAndValues } // Topology contains data that all topology messages MAY contain. type Topology struct { ID primitive.ObjectID // Driver's unique ID for this topology Message string // Message associated with the topology } // SerializeTopology serializes a Topology message into a slice of keys and // values that can be passed to a logger. func SerializeTopology(topo Topology, extraKV ...interface{}) KeyValues { keysAndValues := KeyValues{ KeyTopologyID, topo.ID.Hex(), } // Add the optional keys and values. for i := 0; i < len(extraKV); i += 2 { keysAndValues.Add(extraKV[i].(string), extraKV[i+1]) } return keysAndValues }	11.14 KB	2025-05-25 12:27
📄 component_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import ( "testing" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" ) func verifySerialization(t testing.T, got, want KeyValues) { t.Helper() for i := 0; i < len(got); i += 2 { assert.Equal(t, want[i], got[i], "key position mismatch") assert.Equal(t, want[i+1], got[i+1], "value position mismatch for %q", want[i]) } } func TestSerializeCommand(t testing.T) { t.Parallel() serverConnectionID := int64(100) serviceID := primitive.NewObjectID() tests := []struct { name string cmd Command extraKeysAndValues []interface{} want KeyValues }{ { name: "empty", want: KeyValues{ KeyCommandName, "", KeyDatabaseName, "", KeyDriverConnectionID, uint64(0), KeyMessage, "", KeyOperationID, int32(0), KeyRequestID, int64(0), KeyServerHost, "", }, }, { name: "complete Command object", cmd: Command{ DriverConnectionID: 1, Name: "foo", DatabaseName: "db", Message: "bar", OperationID: 2, RequestID: 3, ServerHost: "localhost", ServerPort: "27017", ServerConnectionID: &serverConnectionID, ServiceID: &serviceID, }, want: KeyValues{ KeyCommandName, "foo", KeyDatabaseName, "db", KeyDriverConnectionID, uint64(1), KeyMessage, "bar", KeyOperationID, int32(2), KeyRequestID, int64(3), KeyServerHost, "localhost", KeyServerPort, int64(27017), KeyServerConnectionID, serverConnectionID, KeyServiceID, serviceID.Hex(), }, }, } for _, test := range tests { test := test t.Run(test.name, func(t testing.T) { t.Parallel() got := SerializeCommand(test.cmd, test.extraKeysAndValues...) verifySerialization(t, got, test.want) }) } } func TestSerializeConnection(t testing.T) { t.Parallel() tests := []struct { name string conn Connection extraKeysAndValues []interface{} want KeyValues }{ { name: "empty", want: KeyValues{ KeyMessage, "", KeyServerHost, "", }, }, { name: "complete Connection object", conn: Connection{ Message: "foo", ServerHost: "localhost", ServerPort: "27017", }, want: KeyValues{ "message", "foo", "serverHost", "localhost", "serverPort", int64(27017), }, }, } for _, test := range tests { test := test t.Run(test.name, func(t testing.T) { t.Parallel() got := SerializeConnection(test.conn, test.extraKeysAndValues...) verifySerialization(t, got, test.want) }) } } func TestSerializeServer(t testing.T) { t.Parallel() topologyID := primitive.NewObjectID() serverConnectionID := int64(100) tests := []struct { name string srv Server extraKeysAndValues []interface{} want KeyValues }{ { name: "empty", want: KeyValues{ KeyDriverConnectionID, uint64(0), KeyMessage, "", KeyServerHost, "", KeyTopologyID, primitive.ObjectID{}.Hex(), }, }, { name: "complete Server object", srv: Server{ DriverConnectionID: 1, TopologyID: topologyID, Message: "foo", ServerConnectionID: &serverConnectionID, ServerHost: "localhost", ServerPort: "27017", }, want: KeyValues{ KeyDriverConnectionID, uint64(1), KeyMessage, "foo", KeyServerHost, "localhost", KeyTopologyID, topologyID.Hex(), KeyServerConnectionID, serverConnectionID, KeyServerPort, int64(27017), }, }, } for _, test := range tests { test := test t.Run(test.name, func(t testing.T) { t.Parallel() got := SerializeServer(test.srv, test.extraKeysAndValues...) verifySerialization(t, got, test.want) }) } } func TestSerializeTopology(t testing.T) { t.Parallel() topologyID := primitive.NewObjectID() tests := []struct { name string topo Topology extraKeysAndValues []interface{} want KeyValues }{ { name: "empty", want: KeyValues{ KeyTopologyID, primitive.ObjectID{}.Hex(), }, }, { name: "complete Server object", topo: Topology{ ID: topologyID, Message: "foo", }, want: KeyValues{ KeyTopologyID, topologyID.Hex(), KeyMessage, "foo", }, }, } for _, test := range tests { test := test t.Run(test.name, func(t *testing.T) { t.Parallel() got := SerializeTopology(test.topo, test.extraKeysAndValues...) verifySerialization(t, got, test.want) }) } }	4.8 KB	2025-05-25 12:27
📄 context.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import "context" // contextKey is a custom type used to prevent key collisions when using the // context package. type contextKey string const ( contextKeyOperation contextKey = "operation" contextKeyOperationID contextKey = "operationID" ) // WithOperationName adds the operation name to the context. func WithOperationName(ctx context.Context, operation string) context.Context { return context.WithValue(ctx, contextKeyOperation, operation) } // WithOperationID adds the operation ID to the context. func WithOperationID(ctx context.Context, operationID int32) context.Context { return context.WithValue(ctx, contextKeyOperationID, operationID) } // OperationName returns the operation name from the context. func OperationName(ctx context.Context) (string, bool) { operationName := ctx.Value(contextKeyOperation) if operationName == nil { return "", false } return operationName.(string), true } // OperationID returns the operation ID from the context. func OperationID(ctx context.Context) (int32, bool) { operationID := ctx.Value(contextKeyOperationID) if operationID == nil { return 0, false } return operationID.(int32), true }	1.42 KB	2025-05-25 12:27
📄 context_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger_test import ( "context" "testing" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/logger" ) func TestContext_WithOperationName(t testing.T) { t.Parallel() tests := []struct { name string ctx context.Context opName string ok bool }{ { name: "simple", ctx: context.Background(), opName: "foo", ok: true, }, } for _, tt := range tests { tt := tt // Capture the range variable. t.Run(tt.name, func(t testing.T) { t.Parallel() ctx := logger.WithOperationName(tt.ctx, tt.opName) opName, ok := logger.OperationName(ctx) assert.Equal(t, tt.ok, ok) if ok { assert.Equal(t, tt.opName, opName) } }) } } func TestContext_OperationName(t testing.T) { t.Parallel() tests := []struct { name string ctx context.Context opName interface{} ok bool }{ { name: "nil", ctx: context.Background(), opName: nil, ok: false, }, { name: "string type", ctx: context.Background(), opName: "foo", ok: true, }, { name: "non-string type", ctx: context.Background(), opName: int32(1), ok: false, }, } for _, tt := range tests { tt := tt // Capture the range variable. t.Run(tt.name, func(t testing.T) { t.Parallel() ctx := context.Background() if opNameStr, ok := tt.opName.(string); ok { ctx = logger.WithOperationName(tt.ctx, opNameStr) } opName, ok := logger.OperationName(ctx) assert.Equal(t, tt.ok, ok) if ok { assert.Equal(t, tt.opName, opName) } }) } } func TestContext_WithOperationID(t testing.T) { t.Parallel() tests := []struct { name string ctx context.Context opID int32 ok bool }{ { name: "non-zero", ctx: context.Background(), opID: 1, ok: true, }, } for _, tt := range tests { tt := tt // Capture the range variable. t.Run(tt.name, func(t testing.T) { t.Parallel() ctx := logger.WithOperationID(tt.ctx, tt.opID) opID, ok := logger.OperationID(ctx) assert.Equal(t, tt.ok, ok) if ok { assert.Equal(t, tt.opID, opID) } }) } } func TestContext_OperationID(t testing.T) { t.Parallel() tests := []struct { name string ctx context.Context opID interface{} ok bool }{ { name: "nil", ctx: context.Background(), opID: nil, ok: false, }, { name: "i32 type", ctx: context.Background(), opID: int32(1), ok: true, }, { name: "non-i32 type", ctx: context.Background(), opID: "foo", ok: false, }, } for _, tt := range tests { tt := tt // Capture the range variable. t.Run(tt.name, func(t testing.T) { t.Parallel() ctx := context.Background() if opIDI32, ok := tt.opID.(int32); ok { ctx = logger.WithOperationID(tt.ctx, opIDI32) } opName, ok := logger.OperationID(ctx) assert.Equal(t, tt.ok, ok) if ok { assert.Equal(t, tt.opID, opName) } }) } }	3.19 KB	2025-05-25 12:27
📄 io_sink.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import ( "encoding/json" "io" "sync" "time" ) // IOSink writes a JSON-encoded message to the io.Writer. type IOSink struct { enc json.Encoder // encMu protects the encoder from concurrent writes. While the logger // itself does not concurrently write to the sink, the sink may be used // concurrently within the driver. encMu sync.Mutex } // Compile-time check to ensure IOSink implements the LogSink interface. var _ LogSink = &IOSink{} // NewIOSink will create an IOSink object that writes JSON messages to the // provided io.Writer. func NewIOSink(out io.Writer) IOSink { return &IOSink{ enc: json.NewEncoder(out), } } // Info will write a JSON-encoded message to the io.Writer. func (sink IOSink) Info(_ int, msg string, keysAndValues ...interface{}) { kvMap := make(map[string]interface{}, len(keysAndValues)/2+2) kvMap[KeyTimestamp] = time.Now().UnixNano() kvMap[KeyMessage] = msg for i := 0; i < len(keysAndValues); i += 2 { kvMap[keysAndValues[i].(string)] = keysAndValues[i+1] } sink.encMu.Lock() defer sink.encMu.Unlock() _ = sink.enc.Encode(kvMap) } // Error will write a JSON-encoded error message to the io.Writer. func (sink IOSink) Error(err error, msg string, kv ...interface{}) { kv = append(kv, KeyError, err.Error()) sink.Info(0, msg, kv...) }	1.55 KB	2025-05-25 12:27
📄 level.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import "strings" // DiffToInfo is the number of levels in the Go Driver that come before the // "Info" level. This should ensure that "Info" is the 0th level passed to the // sink. const DiffToInfo = 1 // Level is an enumeration representing the log severity levels supported by // the driver. The order of the logging levels is important. The driver expects // that a user will likely use the "logr" package to create a LogSink, which // defaults InfoLevel as 0. Any additions to the Level enumeration before the // InfoLevel will need to also update the "diffToInfo" constant. type Level int const ( // LevelOff suppresses logging. LevelOff Level = iota // LevelInfo enables logging of informational messages. These logs are // high-level information about normal driver behavior. LevelInfo // LevelDebug enables logging of debug messages. These logs can be // voluminous and are intended for detailed information that may be // helpful when debugging an application. LevelDebug ) const ( levelLiteralOff = "off" levelLiteralEmergency = "emergency" levelLiteralAlert = "alert" levelLiteralCritical = "critical" levelLiteralError = "error" levelLiteralWarning = "warning" levelLiteralNotice = "notice" levelLiteralInfo = "info" levelLiteralDebug = "debug" levelLiteralTrace = "trace" ) var LevelLiteralMap = map[string]Level{ levelLiteralOff: LevelOff, levelLiteralEmergency: LevelInfo, levelLiteralAlert: LevelInfo, levelLiteralCritical: LevelInfo, levelLiteralError: LevelInfo, levelLiteralWarning: LevelInfo, levelLiteralNotice: LevelInfo, levelLiteralInfo: LevelInfo, levelLiteralDebug: LevelDebug, levelLiteralTrace: LevelDebug, } // ParseLevel will check if the given string is a valid environment variable // for a logging severity level. If it is, then it will return the associated // driver's Level. The default Level is “LevelOff”. func ParseLevel(str string) Level { for literal, level := range LevelLiteralMap { if strings.EqualFold(literal, str) { return level } } return LevelOff }	2.35 KB	2025-05-25 12:27
📄 logger.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 // Package logger provides the internal logging solution for the MongoDB Go // Driver. package logger import ( "fmt" "os" "strconv" "strings" ) // DefaultMaxDocumentLength is the default maximum number of bytes that can be // logged for a stringified BSON document. const DefaultMaxDocumentLength = 1000 // TruncationSuffix are trailing ellipsis "..." appended to a message to // indicate to the user that truncation occurred. This constant does not count // toward the max document length. const TruncationSuffix = "..." const logSinkPathEnvVar = "MONGODB_LOG_PATH" const maxDocumentLengthEnvVar = "MONGODB_LOG_MAX_DOCUMENT_LENGTH" // LogSink represents a logging implementation, this interface should be 1-1 // with the exported "LogSink" interface in the mongo/options package. type LogSink interface { // Info logs a non-error message with the given key/value pairs. The // level argument is provided for optional logging. Info(level int, msg string, keysAndValues ...interface{}) // Error logs an error, with the given message and key/value pairs. Error(err error, msg string, keysAndValues ...interface{}) } // Logger represents the configuration for the internal logger. type Logger struct { ComponentLevels map[Component]Level // Log levels for each component. Sink LogSink // LogSink for log printing. MaxDocumentLength uint // Command truncation width. logFile os.File // File to write logs to. } // New will construct a new logger. If any of the given options are the // zero-value of the argument type, then the constructor will attempt to // source the data from the environment. If the environment has not been set, // then the constructor will the respective default values. func New(sink LogSink, maxDocLen uint, compLevels map[Component]Level) (Logger, error) { logger := &Logger{ ComponentLevels: selectComponentLevels(compLevels), MaxDocumentLength: selectMaxDocumentLength(maxDocLen), } sink, logFile, err := selectLogSink(sink) if err != nil { return nil, err } logger.Sink = sink logger.logFile = logFile return logger, nil } // Close will close the logger's log file, if it exists. func (logger Logger) Close() error { if logger.logFile != nil { return logger.logFile.Close() } return nil } // LevelComponentEnabled will return true if the given LogLevel is enabled for // the given LogComponent. If the ComponentLevels on the logger are enabled for // "ComponentAll", then this function will return true for any level bound by // the level assigned to "ComponentAll". // // If the level is not enabled (i.e. LevelOff), then false is returned. This is // to avoid false positives, such as returning "true" for a component that is // not enabled. For example, without this condition, an empty LevelComponent // would be considered "enabled" for "LevelOff". func (logger Logger) LevelComponentEnabled(level Level, component Component) bool { if level == LevelOff { return false } if logger.ComponentLevels == nil { return false } return logger.ComponentLevels[component] >= level \|\| logger.ComponentLevels[ComponentAll] >= level } // Print will synchronously print the given message to the configured LogSink. // If the LogSink is nil, then this method will do nothing. Future work could be done to make // this method asynchronous, see buffer management in libraries such as log4j. // // It's worth noting that many structured logs defined by DBX-wide // specifications include a "message" field, which is often shared with the // message arguments passed to this print function. The "Info" method used by // this function is implemented based on the go-logr/logr LogSink interface, // which is why "Print" has a message parameter. Any duplication in code is // intentional to adhere to the logr pattern. func (logger Logger) Print(level Level, component Component, msg string, keysAndValues ...interface{}) { // If the level is not enabled for the component, then // skip the message. if !logger.LevelComponentEnabled(level, component) { return } // If the sink is nil, then skip the message. if logger.Sink == nil { return } logger.Sink.Info(int(level)-DiffToInfo, msg, keysAndValues...) } // Error logs an error, with the given message and key/value pairs. // It functions similarly to Print, but may have unique behavior, and should be // preferred for logging errors. func (logger Logger) Error(err error, msg string, keysAndValues ...interface{}) { if logger.Sink == nil { return } logger.Sink.Error(err, msg, keysAndValues...) } // selectMaxDocumentLength will return the integer value of the first non-zero // function, with the user-defined function taking priority over the environment // variables. For the environment, the function will attempt to get the value of // "MONGODB_LOG_MAX_DOCUMENT_LENGTH" and parse it as an unsigned integer. If the // environment variable is not set or is not an unsigned integer, then this // function will return the default max document length. func selectMaxDocumentLength(maxDocLen uint) uint { if maxDocLen != 0 { return maxDocLen } maxDocLenEnv := os.Getenv(maxDocumentLengthEnvVar) if maxDocLenEnv != "" { maxDocLenEnvInt, err := strconv.ParseUint(maxDocLenEnv, 10, 32) if err == nil { return uint(maxDocLenEnvInt) } } return DefaultMaxDocumentLength } const ( logSinkPathStdout = "stdout" logSinkPathStderr = "stderr" ) // selectLogSink will return the first non-nil LogSink, with the user-defined // LogSink taking precedence over the environment-defined LogSink. If no LogSink // is defined, then this function will return a LogSink that writes to stderr. func selectLogSink(sink LogSink) (LogSink, os.File, error) { if sink != nil { return sink, nil, nil } path := os.Getenv(logSinkPathEnvVar) lowerPath := strings.ToLower(path) if lowerPath == string(logSinkPathStderr) { return NewIOSink(os.Stderr), nil, nil } if lowerPath == string(logSinkPathStdout) { return NewIOSink(os.Stdout), nil, nil } if path != "" { logFile, err := os.OpenFile(path, os.O_APPEND\|os.O_CREATE\|os.O_RDWR, 0666) if err != nil { return nil, nil, fmt.Errorf("unable to open log file: %w", err) } return NewIOSink(logFile), logFile, nil } return NewIOSink(os.Stderr), nil, nil } // selectComponentLevels returns a new map of LogComponents to LogLevels that is // the result of merging the user-defined data with the environment, with the // user-defined data taking priority. func selectComponentLevels(componentLevels map[Component]Level) map[Component]Level { selected := make(map[Component]Level) // Determine if the "MONGODB_LOG_ALL" environment variable is set. var globalEnvLevel Level if all := os.Getenv(mongoDBLogAllEnvVar); all != "" { level := ParseLevel(all) globalEnvLevel = &level } for envVar, component := range componentEnvVarMap { // If the component already has a level, then skip it. if _, ok := componentLevels[component]; ok { selected[component] = componentLevels[component] continue } // If the "MONGODB_LOG_ALL" environment variable is set, then // set the level for the component to the value of the // environment variable. if globalEnvLevel != nil { selected[component] = *globalEnvLevel continue } // Otherwise, set the level for the component to the value of // the environment variable. selected[component] = ParseLevel(os.Getenv(envVar)) } return selected } // truncate will truncate a string to the given width, appending "..." to the // end of the string if it is truncated. This routine is safe for multi-byte // characters. func truncate(str string, width uint) string { if width == 0 { return "" } if len(str) <= int(width) { return str } // Truncate the byte slice of the string to the given width. newStr := str[:width] // Check if the last byte is at the beginning of a multi-byte character. // If it is, then remove the last byte. if newStr[len(newStr)-1]&0xC0 == 0xC0 { return newStr[:len(newStr)-1] + TruncationSuffix } // Check if the last byte is in the middle of a multi-byte character. If // it is, then step back until we find the beginning of the character. if newStr[len(newStr)-1]&0xC0 == 0x80 { for i := len(newStr) - 1; i >= 0; i-- { if newStr[i]&0xC0 == 0xC0 { return newStr[:i] + TruncationSuffix } } } return newStr + TruncationSuffix } // FormatMessage formats a BSON document for logging. The document is truncated // to the given width. func FormatMessage(msg string, width uint) string { if len(msg) == 0 { return "{}" } return truncate(msg, width) }	8.74 KB	2025-05-25 12:27
📄 logger_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package logger import ( "bytes" "encoding/json" "fmt" "os" "reflect" "sync" "testing" "go.mongodb.org/mongo-driver/internal/assert" ) type mockLogSink struct{} func (mockLogSink) Info(int, string, ...interface{}) {} func (mockLogSink) Error(error, string, ...interface{}) {} func BenchmarkLogger(b testing.B) { b.ReportAllocs() b.ResetTimer() b.Run("Print", func(b testing.B) { b.ReportAllocs() b.ResetTimer() logger, err := New(mockLogSink{}, 0, map[Component]Level{ ComponentCommand: LevelDebug, }) if err != nil { b.Fatal(err) } b.RunParallel(func(pb testing.PB) { for pb.Next() { logger.Print(LevelInfo, ComponentCommand, "foo", "bar", "baz") } }) }) } func mockKeyValues(length int) (KeyValues, map[string]interface{}) { keysAndValues := KeyValues{} m := map[string]interface{}{} for i := 0; i < length; i++ { keyName := fmt.Sprintf("key%d", i) valueName := fmt.Sprintf("value%d", i) keysAndValues.Add(keyName, valueName) m[keyName] = valueName } return keysAndValues, m } func BenchmarkIOSinkInfo(b testing.B) { keysAndValues, _ := mockKeyValues(10) b.ReportAllocs() b.ResetTimer() sink := NewIOSink(bytes.NewBuffer(nil)) b.RunParallel(func(pb testing.PB) { for pb.Next() { sink.Info(0, "foo", keysAndValues...) } }) } func TestIOSinkInfo(t testing.T) { t.Parallel() const threshold = 1000 mockKeyValues, kvmap := mockKeyValues(10) buf := new(bytes.Buffer) sink := NewIOSink(buf) wg := sync.WaitGroup{} wg.Add(threshold) for i := 0; i < threshold; i++ { go func() { defer wg.Done() sink.Info(0, "foo", mockKeyValues...) }() } wg.Wait() dec := json.NewDecoder(buf) for dec.More() { var m map[string]interface{} if err := dec.Decode(&m); err != nil { t.Fatalf("error unmarshaling JSON: %v", err) } delete(m, KeyTimestamp) delete(m, KeyMessage) if !reflect.DeepEqual(m, kvmap) { t.Fatalf("expected %v, got %v", kvmap, m) } } } func TestSelectMaxDocumentLength(t testing.T) { for _, tcase := range []struct { name string arg uint expected uint env map[string]string }{ { name: "default", arg: 0, expected: DefaultMaxDocumentLength, }, { name: "non-zero", arg: 100, expected: 100, }, { name: "valid env", arg: 0, expected: 100, env: map[string]string{ maxDocumentLengthEnvVar: "100", }, }, { name: "invalid env", arg: 0, expected: DefaultMaxDocumentLength, env: map[string]string{ maxDocumentLengthEnvVar: "foo", }, }, } { tcase := tcase t.Run(tcase.name, func(t testing.T) { for k, v := range tcase.env { t.Setenv(k, v) } actual := selectMaxDocumentLength(tcase.arg) if actual != tcase.expected { t.Errorf("expected %d, got %d", tcase.expected, actual) } }) } } func TestSelectLogSink(t testing.T) { for _, tcase := range []struct { name string arg LogSink expected LogSink env map[string]string }{ { name: "default", arg: nil, expected: NewIOSink(os.Stderr), }, { name: "non-nil", arg: mockLogSink{}, expected: mockLogSink{}, }, { name: "stdout", arg: nil, expected: NewIOSink(os.Stdout), env: map[string]string{ logSinkPathEnvVar: logSinkPathStdout, }, }, { name: "stderr", arg: nil, expected: NewIOSink(os.Stderr), env: map[string]string{ logSinkPathEnvVar: logSinkPathStderr, }, }, } { tcase := tcase t.Run(tcase.name, func(t testing.T) { for k, v := range tcase.env { t.Setenv(k, v) } actual, _, _ := selectLogSink(tcase.arg) if !reflect.DeepEqual(actual, tcase.expected) { t.Errorf("expected %+v, got %+v", tcase.expected, actual) } }) } } func TestSelectedComponentLevels(t testing.T) { for _, tcase := range []struct { name string arg map[Component]Level expected map[Component]Level env map[string]string }{ { name: "default", arg: nil, expected: map[Component]Level{ ComponentCommand: LevelOff, ComponentTopology: LevelOff, ComponentServerSelection: LevelOff, ComponentConnection: LevelOff, }, }, { name: "non-nil", arg: map[Component]Level{ ComponentCommand: LevelDebug, }, expected: map[Component]Level{ ComponentCommand: LevelDebug, ComponentTopology: LevelOff, ComponentServerSelection: LevelOff, ComponentConnection: LevelOff, }, }, { name: "valid env", arg: nil, expected: map[Component]Level{ ComponentCommand: LevelDebug, ComponentTopology: LevelInfo, ComponentServerSelection: LevelOff, ComponentConnection: LevelOff, }, env: map[string]string{ mongoDBLogCommandEnvVar: levelLiteralDebug, mongoDBLogTopologyEnvVar: levelLiteralInfo, }, }, { name: "invalid env", arg: nil, expected: map[Component]Level{ ComponentCommand: LevelOff, ComponentTopology: LevelOff, ComponentServerSelection: LevelOff, ComponentConnection: LevelOff, }, env: map[string]string{ mongoDBLogCommandEnvVar: "foo", mongoDBLogTopologyEnvVar: "bar", }, }, } { tcase := tcase t.Run(tcase.name, func(t testing.T) { for k, v := range tcase.env { t.Setenv(k, v) } actual := selectComponentLevels(tcase.arg) for k, v := range tcase.expected { if actual[k] != v { t.Errorf("expected %d, got %d", v, actual[k]) } } }) } } func TestTruncate(t testing.T) { t.Parallel() for _, tcase := range []struct { name string arg string width uint expected string }{ { name: "empty", arg: "", width: 0, expected: "", }, { name: "short", arg: "foo", width: DefaultMaxDocumentLength, expected: "foo", }, { name: "long", arg: "foo bar baz", width: 9, expected: "foo bar b...", }, { name: "multi-byte", arg: "你好", width: 4, expected: "你...", }, } { tcase := tcase t.Run(tcase.name, func(t testing.T) { t.Parallel() actual := truncate(tcase.arg, tcase.width) if actual != tcase.expected { t.Errorf("expected %q, got %q", tcase.expected, actual) } }) } } func TestLogger_LevelComponentEnabled(t testing.T) { t.Parallel() tests := []struct { name string logger Logger level Level component Component want bool }{ { name: "zero", logger: Logger{}, level: LevelOff, component: ComponentCommand, want: false, }, { name: "empty", logger: Logger{ ComponentLevels: map[Component]Level{}, }, level: LevelOff, component: ComponentCommand, want: false, // LevelOff should never be considered enabled. }, { name: "one level below", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentCommand: LevelDebug, }, }, level: LevelInfo, component: ComponentCommand, want: true, }, { name: "equal levels", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentCommand: LevelDebug, }, }, level: LevelDebug, component: ComponentCommand, want: true, }, { name: "one level above", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentCommand: LevelInfo, }, }, level: LevelDebug, component: ComponentCommand, want: false, }, { name: "component mismatch", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentCommand: LevelDebug, }, }, level: LevelDebug, component: ComponentTopology, want: false, }, { name: "component all enables with topology", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, }, }, level: LevelDebug, component: ComponentTopology, want: true, }, { name: "component all enables with server selection", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, }, }, level: LevelDebug, component: ComponentServerSelection, want: true, }, { name: "component all enables with connection", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, }, }, level: LevelDebug, component: ComponentConnection, want: true, }, { name: "component all enables with command", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, }, }, level: LevelDebug, component: ComponentCommand, want: true, }, { name: "component all enables with all", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, }, }, level: LevelDebug, component: ComponentAll, want: true, }, { name: "component all does not enable with lower level", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelInfo, }, }, level: LevelDebug, component: ComponentCommand, want: false, }, { name: "component all has a lower log level than command", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelInfo, ComponentCommand: LevelDebug, }, }, level: LevelDebug, component: ComponentCommand, want: true, }, { name: "component all has a higher log level than command", logger: Logger{ ComponentLevels: map[Component]Level{ ComponentAll: LevelDebug, ComponentCommand: LevelInfo, }, }, level: LevelDebug, component: ComponentCommand, want: true, }, } for _, tcase := range tests { tcase := tcase // Capture the range variable. t.Run(tcase.name, func(t testing.T) { t.Parallel() got := tcase.logger.LevelComponentEnabled(tcase.level, tcase.component) assert.Equal(t, tcase.want, got, "unexpected result for LevelComponentEnabled") }) } }	10.21 KB	2025-05-25 12:27

Terminal