Tutoriel d'utilisation simple de Golang Logrus

Ce qui suit est un tutoriel simple d'utilisation de Golang Logrus de la colonne tutoriel golang. J'espère qu'il sera utile aux amis dans le besoin !

Tutoriel facile à utiliser de Golang Logrus

La manière la plus simple d'utiliser Logrus :

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

Veuillez noter qu'il est entièrement compatible avec l'API avec stdlib logger, donc Vous pouvez remplacer l'importation n'importe où dans le journal, connectez-vous "github.com/sirupsen/logrus" . Vous pouvez également tout personnaliser :

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

Pour une utilisation plus avancée, pour un grand projet, une instance globale de logrus, c'est-à-dire l'objet logger, est souvent nécessaire pour enregistrer tous les logs du projet. Un exemple est :

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

Fields :

Logrus encourage une journalisation structurée et minutieuse via des champs de journalisation plutôt que des messages d'erreur longs et impossibles à analyser. Par exemple, au lieu de : log.Fatalf("Failed to send event %s to topic %s with key %d"), vous devez utiliser :

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

Nous avons constaté que cette API vous oblige à réfléchir dans l'ordre pour produire des enregistrements de journal plus utiles sous la forme de messages de journal. Nous avons rencontré d'innombrables situations dans lesquelles le simple ajout d'un champ à une instruction de journal déjà existante nous a fait gagner du temps. L'appel WithFields est facultatif.

En général, l'utilisation de l'une des fonctions de la famille printf avec Logrus doit être considérée comme un indice et vous devez ajouter un champ, cependant, vous pouvez toujours utiliser les fonctions de la famille printf avec Logrus.

Champs par défaut

Il est souvent utile de toujours joindre des champs aux instructions de journal dans votre application ou une partie d'une application. Par exemple, vous souhaiterez peut-être toujours enregistrer request_id et user_ip dans le contexte d'une requête. Au lieu d'écrire log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip}) sur chaque ligne, vous pouvez créer un logrus.Entry en passant :

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

Vous pouvez ajouter des hooks pour les niveaux de journalisation. Par exemple, envoyez les erreurs au service de suivi des exceptions sur les informations d'erreur, de fatalité et de panique à StatsD ou enregistrez-vous à plusieurs emplacements en même temps, tels que Syslog.

Logrus est livré avec des crochets intégrés. Ajoutez-les ou votre hook init personnalisé :

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

Remarque : les hooks Syslog prennent également en charge la connexion au syslog local (tel que "/dev/log" ou "/var/run/syslog" ou "/var /run/ enregistrer"). Pour plus de détails, consultez le fichier README des hooks Syslog.

Une liste des hooks de service actuellement connus peut être trouvée sur cette page wiki.

Niveaux de journalisation

Logrus dispose de sept niveaux de journalisation : trace, débogage, informations, avertissement, erreur, critique et urgence.

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

Vous pouvez définir le niveau de journalisation sur Logger et il n'enregistrera alors que les entrées avec cette gravité ou plus :

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

log.Level = logrus.DebugLevel si appliqué Si votre programme a un débogage ou un environnement verbeux, il peut être utile de l'installer ici.

Entrées

En plus des champs ajoutés WithField ou WithFields certains champs seront automatiquement ajoutés à tous les événements de journalisation :

heure. L'horodatage de la création de l'entrée.

msg. Le message de journal transmis à AddFields après avoir appelé {Info, Warn, Error, Fatal, Panic}. Par exemple, Échec de l'envoi de l'événement.

niveau. Niveau de journalisation. Par exemple des informations.

Environnement

Logrus n'a aucune notion d'environnement.

Si vous souhaitez utiliser des hooks et des formateurs uniquement dans un environnement spécifique, vous devez le gérer vous-même. Par exemple, si votre application possède une variable globale Environment, qui est une représentation sous forme de chaîne de l'environnement, vous pouvez effectuer ce qui suit :

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

Cette configuration est utilisée comme prévu par logrus, mais le JSON en production uniquement. n'est utile que lors de l'utilisation d'outils tels que Splunk ou Logstash pour l'agrégation de journaux.

Formatter

Le formateur de journal intégré est :

logrus.TextFormatter. Les événements sont enregistrés en couleur si la sortie standard est un terminal, sinon les événements sont enregistrés en couleur.

Remarque : Pour forcer la sortie des couleurs lorsqu'il n'y a pas d'ATS, définissez le champ ForceColors sur true. Pour ne pas forcer la sortie en couleur même avec un TTY, définissez le champ DisableColors sur true. Pour Windows, consultez github.com/mattn/go-colorable.

Lorsque les couleurs sont activées, les niveaux seront tronqués à 4 caractères par défaut. Pour désactiver la troncature, définissez le champ DisableLevelTruncation sur true.

Lors de la sortie vers un ATS, il est souvent utile de parcourir visuellement les colonnes où tous les niveaux ont la même largeur. Activez ce comportement en ajoutant un remplissage au texte du niveau, en définissant le champ PadLevelText sur true.

Toutes les options sont répertoriées dans la documentation générée.

logrus.JSONFormatter. Enregistrez les champs au format JSON.

Toutes les options sont répertoriées dans la documentation générée.

Formateur de journaux tiers :

FluentdFormatter. Formatez les entrées qui peuvent être analysées par Kubernetes et Google Container Engine.

GELF. Formatez les entrées pour qu'elles soient conformes à la spécification GELF 1.1 de Graylog.

logstash. Consigner les champs en tant qu’événements Logstash.

préfixé. Affiche les sources d'entrée du journal ainsi que des mises en page alternatives.

zalgo. Faites appel au pouvoir de Zalgo.

formateur de logrus imbriqué. Convertissez les champs logarithmiques en structures imbriquées.

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)可以压缩和删除旧日志条目的外部程序（如）完成。它不应该是应用程序级记录器的功能。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!