Vai:crea l'interfaccia io.Writer per la registrazione al database mongodb

Ogni operazione di registrazione effettua una singola chiamata al metodo Writer's Write. Un Logger può essere utilizzato contemporaneamente da più goroutine; garantisce di serializzare l'accesso al writer.

Quindi in pratica devi solo creare un tipo che implementi io.Writer , e il cui Write() crea un nuovo documento con il contenuto della porzione di byte e lo salva in MongoDB.

Ecco una semplice implementazione che lo fa:

type MongoWriter struct {
    sess *mgo.Session
}

func (mw *MongoWriter) Write(p []byte) (n int, err error) {
    c := mw.sess.DB("").C("log")
    err = c.Insert(bson.M{
        "created": time.Now(),
        "msg":     string(p),
    })
    if err != nil {
        return
    }
    return len(p), nil
}

Usandolo:

sess := ... // Get a MongoDB session

mw := &MongoWriter{sess}
log.SetOutput(mw)

// Now the default Logger of the log package uses our MongoWriter.
// Generate a log message that will be inserted into MongoDB:
log.Println("I'm the first log message.")
log.Println("I'm multi-line,\nbut will still be in a single log message.")

Ovviamente se stai usando un altro log.Logger esempio, imposta il MongoWriter a quello, ad es.:

mylogger := log.New(mw, "", 0)
mylogger.Println("Custom logger")

Nota che i messaggi di registro terminano con newline come log.Logger lo aggiunge anche se il messaggio di registro stesso non termina con una nuova riga. Se non vuoi registrare la nuova riga finale, puoi semplicemente tagliarla, ad esempio:

func (mw *MongoWriter) Write(p []byte) (n int, err error) {
    origLen := len(p)
    if len(p) > 0 && p[len(p)-1] == '\n' {
        p = p[:len(p)-1] // Cut terminating newline
    }

    c := mw.sess.DB("").C("log")

    // ... the rest is the same

    return origLen, nil // Must return original length (we resliced p)
}