Registro

Overview

En esta guía, aprenderá a usar el controlador para configurar el registro de su aplicación. El propósito del registro es 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 registrador en su Client Por ejemplo, llame al método SetLoggerOptions() al crear su objeto ClientOptions. El método SetLoggerOptions() toma un tipo LoggerOptions como parámetro. Configure este tipo LoggerOptions para configurar el registrador de su 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

Integrar registradores de terceros

Hay muchos paquetes de registro de terceros disponibles en Go. Para usar un registrador de terceros en su aplicación, cree un registrador y asígnelo como receptor en su instancia 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.