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 los mensajes con un nivel de severidad o nivel de detalle que usted puede especificar. Al habilitar un registrador en su aplicación, puede recibir información sobre las actividades de su aplicación a un nivel alto, detallado o intermedio.

Habilitar registro

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

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

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, llame al método options.Logger(). La siguiente tabla describe cómo establecer propiedades en un tipo LoggerOptions para configurar el registrador. La primera columna enumera las propiedades LoggerOptions, la segunda las describe y la tercera enumera el método de establecimiento correspondiente y los parámetros para 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 usar un registrador personalizado, defina una estructura de registrador e implemente los métodos Info() y Error() para ella. A continuación, configure el registrador como 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, consulte la guía Crear un MongoClient.