जाओ:मोंगोडब डेटाबेस में लॉगिंग के लिए io.Writer इंटीफेस बनाएं

यह आसानी से संभव है, क्योंकि log.Logger प्रकार गारंटी देता है कि प्रत्येक लॉग संदेश गंतव्य तक पहुंचा दिया जाता है io.Writer एक Writer.Write() . के साथ कॉल करें:

प्रत्येक लॉगिंग ऑपरेशन राइटर की राइट मेथड को सिंगल कॉल करता है। एक लकड़हारा एक साथ कई गोरोइन से उपयोग किया जा सकता है; यह लेखक तक पहुंच को क्रमबद्ध करने की गारंटी देता है।

तो मूल रूप से आपको केवल एक प्रकार बनाने की आवश्यकता है जो io.Writer . को लागू करता है , और जिसका Write() विधि बाइट स्लाइस की सामग्री के साथ एक नया दस्तावेज़ बनाती है, और इसे MongoDB में सहेजती है।

यहाँ एक सरल कार्यान्वयन है जो यह करता है:

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
}

इसका उपयोग करना:

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

स्पष्ट रूप से यदि आप किसी अन्य log.Logger . का उपयोग कर रहे हैं उदाहरण के लिए, MongoWriter सेट करें उसके लिए, उदा.:

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

ध्यान दें कि लॉग संदेश log.Logger . के रूप में नई पंक्ति के साथ समाप्त होते हैं इसे जोड़ता है भले ही लॉग संदेश स्वयं न्यूलाइन के साथ समाप्त न हो। यदि आप अंतिम नई पंक्ति को लॉग नहीं करना चाहते हैं, तो आप इसे आसानी से काट सकते हैं, उदा.:

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