Go :Créer une interface io.Writer pour la connexion à la base de données mongodb

C'est facilement faisable, car le log.Logger type garantit que chaque message de journal est livré à la destination io.Writer avec un seul Writer.Write() appeler :

Chaque opération de journalisation effectue un seul appel à la méthode Writer de Writer. Un Logger peut être utilisé simultanément à partir de plusieurs goroutines; il garantit de sérialiser l'accès au Writer.

Donc, fondamentalement, il vous suffit de créer un type qui implémente io.Writer , et dont Write() La méthode crée un nouveau document avec le contenu de la tranche d'octets et l'enregistre dans MongoDB.

Voici une implémentation simple qui fait cela :

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
}

Utilisation :

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.")

Évidemment si vous utilisez un autre log.Logger instance, définissez le MongoWriter à cela, par exemple :

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

Notez que les messages de journal se terminent par une nouvelle ligne comme log.Logger l'ajoute même si le message de journal lui-même ne se termine pas par une nouvelle ligne. Si vous ne souhaitez pas enregistrer la nouvelle ligne de fin, vous pouvez simplement la couper, par exemple :

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)
}