Einfaches Tutorial zur Verwendung von Golang Logrus

Das Folgende ist ein einfaches Golang Logrus-Tutorial aus der Golang-Tutorial-Kolumne. Ich hoffe, es wird Freunden in Not hilfreich sein!

golang Logrus einfach zu verwendendes Tutorial

Der einfachste Weg, Logrus zu verwenden:

package main
import (
  log "github.com/sirupsen/logrus"
)
func main() {
  log.WithFields(log.Fields{
    "animal": "walrus",
  }).Info("A walrus appears")
}

Bitte beachten Sie, dass es vollständig API-kompatibel mit dem stdlib-Logger ist, sodass Sie den Import an einer beliebigen Stelle in log, log „github.com/“ ersetzen können. Sirupsen /Logrus". Sie können auch alles anpassen:

package main
import (
  "os"
  log "github.com/sirupsen/logrus"
)
func init() {
  // Log 为JSON而不是默认的ASCII格式。
  log.SetFormatter(&log.JSONFormatter{})
  // 输出到标准输出，而不是默认的标准错误
  //可以是任何io.Writer，请参阅下面的文件例如日志。
  log.SetOutput(os.Stdout)
  // 仅记录严重警告以上。
  log.SetLevel(log.WarnLevel)
}
func main() {
  log.WithFields(log.Fields{
    "animal": "walrus",
    "size":   10,
  }).Info("A group of walrus emerges from the ocean")
  log.WithFields(log.Fields{
    "omg":    true,
    "number": 122,
  }).Warn("The group's number increased tremendously!")
  log.WithFields(log.Fields{
    "omg":    true,
    "number": 100,
  }).Fatal("The ice breaks!")
  // 一种常见的模式是通过重用
  //从WithFields返回的logrus.Entry 来重用日志记录语句之间的字段
  contextLogger := log.WithFields(log.Fields{
    "common": "this is a common field",
    "other": "I also should be logged always",
  })
  contextLogger.Info("I'll be logged with common and other field")
  contextLogger.Info("Me too")
}

Für eine fortgeschrittenere Verwendung, für ein großes Projekt, wird oft eine globale Logrus-Instanz, also das Logger-Objekt, benötigt, um alle Protokolle des Projekts aufzuzeichnen. Beispiele hierfür sind:

package main
import (
  "os"
  "github.com/sirupsen/logrus"
)
// 创建记录器的一个新实例。您可以有任意多个实例
var log = logrus.New()
func main() {
  // 用于设置属性的API与程序包级别
  // 导出的记录器有些不同。见Godoc。
  log.Out = os.Stdout
  // 您可以将其设置为任何`io.Writer`
  // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
  // if err == nil {
  //  log.Out = file
  // } else {
  //  log.Info("Failed to log to file, using default stderr")
  // }
  log.WithFields(logrus.Fields{
    "animal": "walrus",
    "size":   10,
  }).Info("A group of walrus emerges from the ocean")
}

Felder:

Logrus fördert eine sorgfältige strukturierte Protokollierung über Protokollierungsfelder anstelle langwieriger und nicht analysierbarer Fehlermeldungen. Anstelle von: log.Fatalf("Fehler beim Senden des Ereignisses %s an Thema %s mit Schlüssel %d") sollten Sie beispielsweise Folgendes verwenden:

log.WithFields(log.Fields{
  "event": event,
  "topic": topic,
  "key": key,
}).Fatal("Failed to send event")

Wir haben festgestellt, dass diese API Sie dazu zwingt, über Möglichkeiten nachzudenken, wie Sie nützlichere Produkte erstellen können Protokollnachrichten Protokollieren. Wir sind auf unzählige Situationen gestoßen, in denen uns das einfache Hinzufügen eines Felds zu einer bereits vorhandenen Protokollanweisung Zeit gespart hat. Der WithFields-Aufruf ist optional.

Im Allgemeinen sollte die Verwendung einer der Funktionen der printf-Familie mit Logrus als Hinweis betrachtet werden und Sie sollten ein Feld hinzufügen. Sie können die Funktionen der printf-Familie jedoch weiterhin mit Logrus verwenden.

Standardfelder

Es ist oft hilfreich, einer Protokollanweisung in Ihrer Anwendung oder einem Teil einer Anwendung immer ein Feld anzuhängen. Beispielsweise möchten Sie möglicherweise immer request_id und user_ip im Kontext einer Anfrage protokollieren. Anstatt log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip}) in jede Zeile zu schreiben, können Sie einen logrus.Entry Pass erstellen:

requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})
requestLogger.Info("something happened on that request") # will log request_id and user_ip
requestLogger.Warn("something not great happened")

Hooks

Sie können Hooks für die Protokollierungsebene hinzufügen . Senden Sie beispielsweise Fehlerinformationen zu Fehlern, schwerwiegenden Fehlern und Panikmeldungen an den Ausnahmeverfolgungsdienst an StatsD oder protokollieren Sie sie gleichzeitig an mehreren Standorten, z. B. Syslog.

Logrus wird mit integrierten Haken geliefert. Fügen Sie diese oder Ihren benutzerdefinierten Hook-Init hinzu:

import (
  log "github.com/sirupsen/logrus"
  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake"
  logrus_syslog "github.com/sirupsen/logrus/hooks/syslog"
  "log/syslog"
)
func init() {
  // Use the Airbrake hook to report errors that have Error severity or above to
  // an exception tracker. You can create custom hooks, see the Hooks section.
  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
  if err != nil {
    log.Error("Unable to connect to local syslog daemon")
  } else {
    log.AddHook(hook)
  }
}

Hinweis: Syslog-Hooks unterstützen auch die Verbindung mit lokalem Syslog (z. B. „/dev/log“ oder „/var/run/syslog“ oder „/var/run/log“ „). . Weitere Informationen finden Sie in der README-Datei zu den Syslog-Hooks.

Eine Liste der derzeit bekannten Service-Hooks finden Sie auf dieser Wiki-Seite.

Protokollierungsstufen

Logrus verfügt über sieben Protokollierungsstufen: Trace, Debug, Info, Warnung, Fehler, Kritisch und Notfall.

log.Trace("Something very low level.")
log.Debug("Useful debugging information.")
log.Info("Something noteworthy happened!")
log.Warn("You should probably take a look at this.")
log.Error("Something failed but I'm not quitting.")
// Calls os.Exit(1) after logging
log.Fatal("Bye.")
// Calls panic() after logging
log.Panic("I'm bailing.")

Sie können die Protokollierungsstufe auf Logger festlegen und es werden nur Einträge mit diesem Schweregrad oder höher protokolliert:

// Will log anything that is info or above (warn, error, fatal, panic). Default.
log.SetLevel(log.InfoLevel)

log.Level = logrus.DebugLevel Wenn die Anwendung über eine Debug- oder ausführliche Umgebung verfügt, kann es sinnvoll sein, diese festzulegen es da oben.

Entries

Zusätzlich zu den hinzugefügten Feldern WithField oder WithFields werden bestimmte Felder automatisch zu allen Protokollierungsereignissen hinzugefügt:

time. Der Zeitstempel, als der Eintrag erstellt wurde.

msg. Die an AddFields übergebene Protokollnachricht nach dem Aufruf von {Info, Warn, Error, Fatal, Panic}. Beispiel: Fehler beim Senden des Ereignisses.

level. Protokollierungsebene. Zum Beispiel Infos.

Umwelt

Logrus hat kein Konzept von Umwelt.

Wenn Sie Hooks und Formatter nur in einer bestimmten Umgebung verwenden möchten, sollten Sie sich selbst darum kümmern. Wenn Ihre Anwendung beispielsweise über eine globale Variable Environment verfügt, die eine Zeichenfolgendarstellung der Umgebung ist, können Sie Folgendes tun:

import (
  log "github.com/sirupsen/logrus"
)
init() {
  // do something here to set environment depending on an environment variable
  // or command-line flag
  if Environment == "production" {
    log.SetFormatter(&log.JSONFormatter{})
  } else {
    // The TextFormatter is default, you don't actually have to do this.
    log.SetFormatter(&log.TextFormatter{})
  }
}

Diese Konfiguration wird wie erwartet von Logrus verwendet, aber der JSON in der Produktion wird nur bei Verwendung von Splunk verwendet oder Logstash und andere Tools sind nur für die Protokollaggregation nützlich.

Formatter

Der integrierte Protokollformatierer ist:

logrus.TextFormatter. Ereignisse werden in Farbe protokolliert, wenn stdout ein TTY ist, andernfalls werden Ereignisse in Farbe protokolliert.

Hinweis: Um die Ausgabe in Farben zu erzwingen, wenn kein TTY vorhanden ist, setzen Sie das Feld „ForceColors“ auf „true“. Um auch mit einem TTY nicht zu erzwingen, dass die Ausgabe in Farbe erfolgt, setzen Sie das Feld „DisableColors“ auf „true“. Für Windows siehe github.com/mattn/go-colorable.

Wenn Farben aktiviert sind, werden die Ebenen standardmäßig auf 4 Zeichen gekürzt. Um die Kürzung zu deaktivieren, legen Sie das Feld „DisableLevelTruncation“ auf „true“ fest.

Bei der Ausgabe auf ein TTY ist es oft hilfreich, Spalten visuell nach unten zu durchsuchen, in denen alle Ebenen die gleiche Breite haben. Aktivieren Sie dieses Verhalten, indem Sie dem Ebenentext Auffüllungen hinzufügen und das Feld „PadLevelText“ auf „true“ setzen.

Alle Optionen sind in der generierten Dokumentation aufgeführt.

logrus.JSONFormatter. Protokollfelder als JSON.

Alle Optionen sind in der generierten Dokumentation aufgeführt.

Protokollformatierer eines Drittanbieters:

FluentdFormatter. Formatieren Sie Einträge, die von Kubernetes und Google Container Engine geparst werden können.

GELF. Formatieren Sie Einträge so, dass sie der GELF 1.1-Spezifikation von Graylog entsprechen.

logstash. Protokollfelder als Logstash-Ereignisse.

vorangestellt. Zeigt Protokolleintragsquellen sowie alternative Layouts an.

zalgo. Rufen Sie die Macht von Zalgo an.

nested-logrus-formatter. Konvertieren Sie logarithmische Felder in verschachtelte Strukturen.

powerful-logrus-formatter。打印日志时获取文件名，日志行号和最新函数名称；Sava日志到文件。

caption-json-formatter。添加了人类可读标题的logrus消息json格式化程序。

您可以通过实现Formatter接口（需要一种Format方法）来定义格式化程序。Format需要一个*Entry。entry.Data是一种 Fields类型（map[string]interface{}），其中包含您的所有字段以及默认字段（请参见上面的条目部分）：

type MyJSONFormatter struct {
}
log.SetFormatter(new(MyJSONFormatter))
func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
  // Note this doesn't include Time, Level and Message which are available on
  // the Entry. Consult `godoc` on information about those fields or read the
  // source of the official loggers.
  serialized, err := json.Marshal(entry.Data)
    if err != nil {
      return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
    }
  return append(serialized, '\n'), nil
}

记录为 io.Writer

Logrus可以转换为io.Writer。该作家是an的结尾，io.Pipe您有责任关闭它。

w := logger.Writer()
defer w.Close()
srv := http.Server{
    // create a stdlib log.Logger that writes to
    // logrus.Logger.
    ErrorLog: log.New(w, "", 0),
}

写入该写入器的每一行都将使用格式化程序和钩子以常规方式打印。这些条目的级别为info。

这意味着我们可以轻松覆盖标准库记录器：

logger := logrus.New()
logger.Formatter = &logrus.JSONFormatter{}
// Use logrus for standard log output
// Note that `log` here references stdlib's log
// Not logrus imported under the name `log`.
log.SetOutput(logger.Writer())

日志轮换

Logrus不提供日志轮换。日志轮换应由logrotate(8)可以压缩和删除旧日志条目的外部程序（如）完成。它不应该是应用程序级记录器的功能。

Das obige ist der detaillierte Inhalt vonEinfaches Tutorial zur Verwendung von Golang Logrus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!