Registro

Overview

En esta guía, puedes aprender cómo usar el controlador para configurar el registro para tu aplicación. El registro tiene como objetivo registrar los eventos del controlador.

Un registrador registra mensajes en un nivel de gravedad o nivel de verbosidad que puedes especificar. Al habilitar un registrador en tu aplicación, podrás recibir información sobre las actividades de tu aplicación a un nivel alto, a un nivel detallado, o en cualquier punto intermedio.

Habilitar registro

Para configurar un registrador en tu instancia Client, llama al método SetLoggerOptions() al crear tu objeto ClientOptions. El método SetLoggerOptions() acepta un tipo LoggerOptions como parámetro. Setea este tipo LoggerOptions para configurar el logger de tu aplicación.

El siguiente código muestra cómo crear un cliente con registro activado:

loggerOptions := options.
     Logger().
     SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug)
clientOptions := options.
     Client().
     ApplyURI(uri).
     SetLoggerOptions(loggerOptions)
client, err := mongo.Connect(clientOptions)

Configurar un registrador

Para crear un objeto LoggerOptions, llama al método options.Logger(). La siguiente tabla describe cómo ajustar las propiedades de un tipo LoggerOptions para configurar tu registrador. La primera columna enumera las propiedades de LoggerOptions, la segunda columna describe las propiedades y la tercera columna enumera el método setter correspondiente y los parámetros de cada propiedad:

// Using named value
comp := options.LogComponentCommand
// Using enumeration
comp := options.LogComponent(1)

lvl := options.LogLevelDebug

loggerOptions := options.
	Logger().
	SetMaxDocumentLength(25).
	SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug)
// Creates options that include the logger specification
clientOptions := options.
	Client().
	ApplyURI(uri).
	SetLoggerOptions(loggerOptions)

type Item struct {
	Name string
}
coll := client.Database("db").Collection("testColl")
_, err = coll.InsertOne(context.TODO(), Item{Name: "grapefruit"})

{"command":"{\"insert\": \"testColl\",\"or...","commandName":"insert","databaseName":"db","driverConnectionId":1,"message":"Command started","operationId":0,"requestId":13,"serverConnectionId":97377,"serverHost":"...","serverPort":27017,"timestamp":...}
{"commandName":"insert","driverConnectionId":1,"durationMS":19,"message":"Command succeeded","operationId":0,"reply":"{\"n\": {\"$numberInt\":\"1\"},...","requestId":13,"serverConnectionId":97377,"serverHost":"...","serverPort":27017,"timestamp":...}

Utiliza un registrador personalizado

Si la librería estándar de logging no satisface tus necesidades, puedes implementar un registrador personalizado. Al personalizar tu configuración de logging, tienes más control sobre el contenido, formato y frecuencia de los mensajes de registro.

Para utilizar un logger personalizado, defina un struct de logger e implemente los métodos Info() y Error() para dicho struct. A continuación, establezca el registrador como el LogSink para su Client llamando al método SetSink() en su instancia LoggerOptions.

type CustomLogger struct {
	io.Writer
	mu sync.Mutex
}

func (logger *CustomLogger) Info(level int, msg string, _ ...any) {
	logger.mu.Lock()
	defer logger.mu.Unlock()
	if options.LogLevel(level+1) == options.LogLevelDebug {
		fmt.Fprintf(logger, "level: %d DEBUG, message: %s\n", level, msg)
	} else {
		fmt.Fprintf(logger, "level: %d INFO, message: %s\n", level, msg)
	}
}
func (logger *CustomLogger) Error(err error, msg string, _ ...any) {
	logger.mu.Lock()
	defer logger.mu.Unlock()
	fmt.Fprintf(logger, "error: %v, message: %s\n", err, msg)
}

buf := bytes.NewBuffer(nil)
sink := &CustomLogger{Writer: buf}
loggerOptions := options.
	Logger().
	SetSink(sink).
	SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug).
	SetComponentLevel(options.LogComponentConnection, options.LogLevelDebug)
// Creates options that include the logger specification
clientOptions := options.
	Client().
	ApplyURI(uri).
	SetLoggerOptions(loggerOptions)

type Item struct {
	Name string
}
coll := client.Database("db").Collection("testColl")
_, err = coll.InsertOne(context.TODO(), Item{Name: "grapefruit"})

level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection pool created
level: 1 DEBUG, message: Connection pool ready
level: 1 DEBUG, message: Connection checkout started
level: 1 DEBUG, message: Connection created
level: 1 DEBUG, message: Connection ready
level: 1 DEBUG, message: Connection checked out
level: 1 DEBUG, message: Command started
level: 1 DEBUG, message: Command succeeded
level: 1 DEBUG, message: Connection checked in

Integra registradores de terceros

Hay muchos paquetes de registro externos disponibles en Go. Para utilizar un registrador de terceros en tu aplicación, crea un registrador y asígnalo como el destino en tu instancia de LoggerOptions.

go get github.com/bombsimon/logrusr/v4
go get github.com/sirupsen/logrus

myLogger := &logrus.Logger{
	Out:   os.Stderr,
	Level: logrus.DebugLevel,
	Formatter: &logrus.JSONFormatter{
		TimestampFormat: "2006-01-02 15:04:05",
		PrettyPrint:     true,
	},
}

sink := logrusr.New(myLogger).GetSink()
// Sets options when configuring the logrus logger
loggerOptions := options.
	Logger().
	SetSink(sink).
	SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug)
// Creates options that include the logger specification
clientOptions := options.
	Client().
	ApplyURI(uri).
	SetLoggerOptions(loggerOptions)

type Item struct {
	Name string
}
coll := client.Database("db").Collection("testColl")
docs := []any{
	Item{Name: "starfruit"},
	Item{Name: "kiwi"},
	Item{Name: "cantaloupe"},
}
_, err = coll.InsertMany(context.TODO(), docs)
if err != nil {
	panic(err)
}
_, err = coll.DeleteOne(context.TODO(), Item{Name: "kiwi"})
if err != nil {
	panic(err)
}

{
  "command": "{\"insert\": \"testColl\", ...}",
  "commandName": "insert",
  "databaseName": "db",
  ...
  "level": "debug",
  "message": "Command started",
  "msg": "Command started",
  ...
  "time": "2023-07-06 10:23:42"
}
{
  "commandName": "insert",
  ...
  "level": "debug",
  "message": "Command succeeded",
  "msg": "Command succeeded",
  ...
  "time": "2023-07-06 10:23:42"
}
{
  "command": "{\"delete\": \"testColl\", ...}",
  "commandName": "delete",
  "databaseName": "db",
  ...
  "level": "debug",
  "message": "Command started",
  "msg": "Command started",
  ...
  "time": "2023-07-06 10:23:42"
}
{
  "commandName": "delete",
  ...
  "level": "debug",
  "message": "Command succeeded",
  "msg": "Command succeeded",
  ...
  "time": "2023-07-06 10:23:42"
}

Información Adicional

Para obtener más información sobre cómo configurar las opciones del cliente, consulta la guía Crear un MongoClient.