Introduction au package log de Go

Le package log intégré à Go offre des fonctionnalités de journalisation simples et adaptables pour tracer l'exécution d'un programme.

1. Importer le package

Pour utiliser les fonctions de journalisation, importez d'abord le package :

import "log"

2. Sortie de journalisation de base

La fonction log.Println permet d'écrire un message dans la sortie journal.

log.Println("Message journal de base.")

Ce package fournit des méthodes fondamentales pour la journalisation. Les plus courantes sont Print, Printf, Println, Fatal, Fatalf, Fatalln, Panic, Panicf, et Panicln.

• Collection Print : Ces méthodes enregistrent des messages d'information standard et ne perturbent pas l'exécution du programme.
  • log.Print(v ...interface{}) : Écrit un message sans saut de ligne.
  • log.Printf(format string, v ...interface{}) : Écrit un message formaté.
  • log.Println(v ...interface{}) : Écrit un message suivi d'un saut de ligne.
• Collection Fatal : Ces méthodes enregistrent une erreur critique et provoquent l'arrêt du programme via os.Exit(1).
  • log.Fatal(v ...interface{}) : Écrit une erreur sans saut de ligne, puis arrête le programme.
  • log.Fatalf(format string, v ...interface{}) : Écrit une erreur formatée, puis arrête le programme.
  • log.Fatalln(v ...interface{}) : Écrit une erreur avec saut de ligne, puis arrête le programme.
• Collection Panic : Ces méthodes enregistrent une erreur critique et déclenchent un panic.
  • log.Panic(v ...interface{}) : Écrit une erreur sans saut de ligne, puis déclenche un panic.
  • log.Panicf(format string, v ...interface{}) : Écrit une erreur formatée, puis déclenche un panic.
  • log.Panicln(v ...interface{}) : Écrit une erreur avec saut de ligne, puis déclenche un panic.

La destination de la sortie peut être modifiée avec log.SetOutput. Le format peut être ajusté avec log.SetFlags (par exemple, pour ajouter un horodatage).

package main

import (
    "log"
    "os"
)

func main() {
    // Rediriger la sortie vers la sortie standard
    log.SetOutput(os.Stdout)

    // Écrire un message d'information
    log.Print("Message d'information général.")

    // Écrire une erreur fatale et terminer
    log.Fatal("Message d'erreur fatale.")

    // Écrire une erreur et déclencher un panic
    log.Panic("Message déclenchant un panic.")
}

3. Personnaliser le format de sortie

Les fonctions log.SetFlags et log.SetPrefix permettent de personnaliser le format des journaux.

log.SetFlags(log.Ldate | log.Ltime)  // Inclure la date et l'heure
log.SetPrefix("[MonApplication] ")    // Ajouter un préfixe
log.Println("Message journal personnalisé.")

4. Écrire dans un fichier

Utilisez log.SetOutput pour diriger les journaux vers un fichier. L'exemple suivant écrit dans journal.log :

fichier, erreur := os.Create("journal.log")
if erreur != nil {
    log.Fatal("Impossible de créer le fichier journal:", erreur)
}
defer fichier.Close()

log.SetOutput(fichier)
log.Println("Message écrit dans le fichier journal.")

5. Gérer des niveaux de journalisation

Le package de base ne gère pas nativement les niveaux (INFO, WARNING, ERROR). On peut l'implémenter avec une fonction dédiée.

const (
    NiveauInfo    = iota
    NiveauAvertissement
    NiveauErreur
)

func enregistrerNiveau(niveau int, message string) {
    var etiquette string
    switch niveau {
    case NiveauInfo:
        etiquette = "[INFO] "
    case NiveauAvertissement:
        etiquette = "[AVERTISSEMENT] "
    case NiveauErreur:
        etiquette = "[ERREUR] "
    }
    log.Println(etiquette + message)
}

enregistrerNiveau(NiveauErreur, "Ceci est un message d'erreur.")

6. Utilisation de Fatal et Panic

log.Fatal et log.Panic sont réservés aux erreurs critiques. Fatal termine le programme avec os.Exit(1), tandis que Panic provoque un arrêt brutal avec une trace de pile.

log.Fatal("Erreur fatale. Le programme va se terminer.")
log.Panic("Panic ! Le programme va s'arrêter brusquement.")

7. Exemple complet

package main

import (
    "log"
    "os"
)

const (
    NiveauInfo          = iota
    NiveauAvertissement
    NiveauErreur
)

func consignerMessage(niveau int, texte string) {
    var prefixe string
    switch niveau {
    case NiveauInfo:
        prefixe = "[INFO] "
    case NiveauAvertissement:
        prefixe = "[AVERTISSEMENT] "
    case NiveauErreur:
        prefixe = "[ERREUR] "
    }
    log.Println(prefixe + texte)
}

func main() {
    // Sortie par défaut (stderr)
    log.Println("Message de journalisation basique.")

    // Format personnalisé
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
    log.SetPrefix("APP ")
    log.Println("Entrée personnalisée.")

    // Sortie vers un fichier
    journal, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal("Échec de l'ouverture du fichier journal:", err)
    }
    defer journal.Close()
    log.SetOutput(journal)

    consignerMessage(NiveauAvertissement, "Avertissement dans le fichier journal.")

    // Démonstration Fatal (commenté pour éviter la terminaison)
    // log.Fatal("Action fatale.")
}

8. Considérations importantes

• Par défaut, la sortie des journaux est dirigée vers os.Stderr (l'erreur standard).
• Pour une application réelle, envisagez d'écrire les journaux dans des fichiers, des bases de données ou des services de centralisation.
• Le package log est conçu pour être sûr lors d'exécutions concurrentes (thread-safe).