Go Iris लॉग्स

अनुप्रयोग फ़ाइल रिकॉर्डर

func main() {
    app := iris.Default()
    // एक फ़ाइल में रिकॉर्ड करें
    // एक फ़ाइल में लिखते समय स्वचालित रूप से रंग निष्क्रिय करें
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // अगर आपको लॉग को फ़ाइल और कंसोल दोनों में लिखने की आवश्यकता है, तो निम्नलिखित कोड का उपयोग करें
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

लॉग आउटपुट रंग नियंत्रण

डिफ़ॉल्ट रूप से, कंसोल पर लॉग आउटपुट टीटीवाई पर आधारित रंगीन होगा।

सामान्य मामलों में स्तर शीर्षक, पाठ, रंग, और स्टाइल कॉस्टमाइज करें।

golog और pio को आयात करें:

import (
    "github.com/kataras/golog"
    "github.com/kataras/pio"
    // [...]
)

किसी लेवल को कस्टमाइज करने के लिए, जैसे कि DebugLevel:

level := golog.Levels[golog.DebugLevel]

आपको स्तर के पाठ, शीर्षक, और स्टाइल पर पूरी नियंत्रण है:

// स्तर का नाम
// छोटे अक्षर का नाम उपयोग किया जाएगा
// पाठ को सही स्तर प्रकार में बदलने के लिए स्ट्रिंग स्तर को परिवर्तित करने के लिए
नाम string
// आल्टरनेटिव नाम वे नाम हैं जिनके जरिए इस विशेष लॉग स्तर का संदर्भ किया जा सकता है
// जैसे कि Name = "warn"
// AlternativeNames = []string{"warning"}, यह एक ऐच्छिक फ़ील्ड है,
// तो हम नाम को एक सरल स्ट्रिंग के रूप में रखते हैं और यह नया फ़ील्ड बनाते हैं।
आल्टरनेटिव नाम []string
// शीर्षक लॉग स्तर का उपसर्ग है।
// उन्हें भी `ColorCode` और `स्टाइल` होते हैं।
// `ColorCode` और `स्टाइल` को लेखकों के बीच संरचित रहना चाहिए।
शीर्षक string
// `और स्टाइल` के लिए एक या एक से अधिक समृद्ध परिकल्पनाएँ।
Style []pio.RichOption

उदाहरण कोड:

level := golog.Levels[golog.DebugLevel]
level.नाम = "डीबग" // डिफ़ॉल्ट
level.शीर्षक = "[DBUG]" // डिफ़ॉल्ट
level.रंग_कोड = pio.पीला // डिफ़ॉल्ट

आउटपुट प्रारूप बदलें:

app.Logger().SetFormat("json", "    ")

एक कस्टम फॉर्मेटर रजिस्टर करें:

app.Logger().RegisterFormatter(new(myFormatter))

golog.फॉर्मैटर interface निम्नलिखित है:

// Formatter लॉग को लॉगर के निर्धारित किए गए संग्रहक को छपाने के लिए जिम्मेदार है
प्रकार
    // फॉर्मैटर का नाम।
    String() string
    // किसी भी विकल्प सेट करें और एक क्लोन ऑब्जेक्ट वापस करें, यदि सामान्य। `Logger.SetFormat` देखें।
    विकल्प विकल्प(opts ...interface{}) Formatter
    // "लॉग" को "डेस्ट" लोगर के लिए लिखता है।
    स्वरूप(करने के लिए io.Writer, लॉग *वस्तु) बूल
}

स्तर द्वारा आउटपुट और प्रारूप बदलें:

app.Logger().SetLevelOutput("error", os.Stderr)
app.Logger().SetLevelFormat("json")

अनुरोध लॉगिंग

ऊपर दिखाए गए अनुप्रयोग लॉगर का प्रमुख उपयोग अनुप्रयोग से संबंधित जानकारी और त्रुटियों को लॉग करने के लिए है। वहीं, नीचे दिखाए गए ऐक्सेस लॉगर का प्रमुख उपयोग आम तौर पर आने वाले HTTP अनुरोध और प्रतिक्रियाओं को लॉग करने के लिए है।

package main

import (
    "os"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/accesslog"
)

// उदाहरण को और उसके टिप्पणियों को ध्यान से पढ़ें।
func makeAccessLog() *accesslog.AccessLog {
    // एक नया ऐक्सेस लॉग मिडलवेयर की शुरुआत करें।
    ac := accesslog.File("./access.log")
    // संसार के लिए लॉगिंग को अक्षम करने के लिए इस पंक्ति को हटाएँ:
    ac.AddOutput(os.Stdout)

    // डिफ़ॉल्ट कॉन्फ़िगरेशन:
    ac.Delim = '|'
    ac.TimeFormat = "2006-01-02 15:04:05"
    ac.Async = false
    ac.IP = true
    ac.BytesReceivedBody = true
    ac.BytesSentBody = true
    ac.BytesReceived = false
    ac.BytesSent = false
    ac.BodyMinify = true
    ac.RequestBody = true
    ac.ResponseBody = false
    ac.KeepMultiLineError = true
    ac.PanicLog = accesslog.LogHandler
    
    // यदि फॉर्मैटर गायब है तो डिफ़ॉल्ट लाइन फ़ॉर्मेट का उपयोग करें:
    // समय|विलम्ब|स्थिति|मेथड|पथ|आईपी|पथ क्यूरी पैरामीटर|प्राप्त बाइट|भेजे गए बाइट|अनुरोध|प्रतिक्रिया|
    //
    // एक कस्टम फॉर्मैटर सेट करें:
    ac.SetFormatter(&accesslog.JSON{
        Indent:    "  ",
        HumanTime: true,
    })
    // ac.SetFormatter(&accesslog.CSV{})
    // ac.SetFormatter(&accesslog.Template{Text: "{{.Code}}"})
    
    return ac
}

func main() {
    ac := makeAccessLog()
    defer ac.Close() // फ़ाइल को बंद करें।

    app := iris.New()
    // मिडलवेयर को रजिस्टर करें (UseRouter का उपयोग करके HTTP त्रुटियों को पकड़ा जा सकता है)।
    app.UseRouter(ac.Handler)
    
    app.Get("/", indexHandler)
    
    app.Listen(":8080")
}

func indexHandler(ctx iris.Context) {
    ctx.WriteString("ठीक है")
}

यहां और उदाहरण पढ़ें: _examples/logging/request-logger.