Surveillance des requêtes SQL effectuées sur Slack

Une simple astuce Go pour recevoir des notifications sur les requêtes lentes, les erreurs inattendues et d'autres journaux importants.

Mon bot Slack m'a interrogé sur une requête SQL de longue durée. Je devrais le réparer dès que possible.

Nous ne pouvons pas gérer ce que nous ne pouvons pas mesurer. Chaque application backend nous oblige à surveiller ses performances sur la base de données. Si une requête particulière ralentit à mesure que la quantité de données augmente, vous devez l'optimiser avant qu'elle ne devienne trop lente.

Alors que Slack est devenu au cœur de notre travail, il change également la façon dont nous surveillons nos systèmes. Même si nous disposons déjà de très bons outils de surveillance, c’est également une excellente idée de demander à un robot Slack de nous indiquer si quelque chose dans le système est en train de disparaître. Par exemple, une requête SQL prend trop de temps ou une erreur fatale se produit dans un package Go spécifique.

Dans cet article de blog, nous vous expliquerons comment configurer un système de journalisation simple prenant déjà en charge ces fonctionnalités et une bibliothèque de bases de données existante pour atteindre cet objectif.

logger est une petite bibliothèque conçue pour être utilisée par les bibliothèques et applications Go. Dans cet exemple, nous utilisons ses trois fonctionnalités importantes :

Il fournit une minuterie simple pour mesurer les performances.
Prend en charge les filtres de sortie complexes, afin que vous puissiez sélectionner les journaux des packages spécifiés. Par exemple, vous pouvez demander à l'enregistreur de générer uniquement des paquets de base de données et de générer uniquement des journaux de minuterie d'une durée supérieure à 500 ms.
Il dispose d'un hook Slack, vous permettant ainsi de filtrer et d'alimenter les journaux dans Slack.
Voyons comment utiliser une minuterie dans cet exemple, plus tard nous utiliserons également des filtres :

package main
import (
    "github.com/azer/logger"
    "time"
)
var (
  users = logger.New("users")
  database = logger.New("database")
)
func main () {
  users.Info("Hi!")
  timer := database.Timer()
  time.Sleep(time.Millisecond * 250) // sleep 250ms
  timer.End("Connected to database")
  users.Error("Failed to create a new user.", logger.Attrs{
    "e-mail": "[email protected]",
  })
  database.Info("Just a random log.")
  fmt.Println("Bye.")
}

Aucune sortie lors de l'exécution de ce programme :

L'enregistreur est silencieux par défaut, il peut donc être utilisé dans la bibliothèque. Nous visualisons simplement le journal via une variable d'environnement : Par exemple :

$ LOG=database@timer go run example-01.go
01:08:54.997 database(250.095587ms): Connected to database.
Bye

Dans l'exemple ci-dessus, nous avons utilisé le filtre database@timer pour afficher la sortie du journal du minuteur dans le package de base de données. Vous pouvez également essayer d'autres filtres, tels que :

LOG=* : Tous les journaux
LOG=users@error,database : tous les journaux d'erreurs des utilisateurs, tous les journaux de la base de données
LOG=*@timer,database@info : journaux du minuteur et journaux d'erreurs de tous les packages et tous les journaux de la base de données
LOG=*,users@mute : Tous les journaux sauf les utilisateurs

Le journal de la console est destiné à l'environnement de développement, mais nous avons besoin que le produit fournisse une interface conviviale. Grâce à slack-hook, on peut facilement l'intégrer en utilisant Slack dans l'exemple ci-dessus :

import (
  "github.com/azer/logger"
  "github.com/azer/logger-slack-hook"
)
func init () {
  logger.Hook(&slackhook.Writer{
    WebHookURL: "https://hooks.slack.com/services/...",
    Channel: "slow-queries",
    Username: "Query Person",
    Filter: func (log *logger.Log) bool {
      return log.Package == "database" && log.Level == "TIMER" && log.Elapsed >= 200
    }
  })
}

Expliquons ce que nous avons fait dans l'exemple ci-dessus :

Ligne n°5 : définissez l'URL du webhook entrant. L'URL est liée ici.
Ligne n°6 : Sélectionnez le canal d'entrée pour le journal de flux.
Ligne n°7 : Nom d'utilisateur affiché de l'expéditeur.
Ligne n°11 : utilisez un filtre de flux pour afficher uniquement les journaux de minuterie datant de plus de 200 ms.
J'espère que cet exemple pourra vous donner une idée générale. Si vous avez d'autres questions, consultez la documentation de l'enregistreur.

crud est une bibliothèque de style ORM pour les bases de données Go. L'une de ses fonctionnalités cachées est que le système de journalisation interne utilise un enregistreur. Cela nous permet de surveiller facilement les requêtes SQL en cours d'exécution.

Voici une requête simple qui renvoie le nom d'utilisateur reçu par e-mail :

func GetUserNameByEmail (email string) (string, error) {
  var name string
  if err := DB.Read(&name, "SELECT name FROM user WHERE email=?", email); err != nil {
    return "", err
  }
  return name, nil
}

D'accord, celui-ci est trop court et on a l'impression qu'il manque quelque chose, ajoutons le contexte complet :

import (
  "github.com/azer/crud"
  _ "github.com/go-sql-driver/mysql"
  "os"
)
var db *crud.DB
func main () {
  var err error
  DB, err = crud.Connect("mysql", os.Getenv("DATABASE_URL"))
  if err != nil {
    panic(err)
  }
  username, err := GetUserNameByEmail("[email protected]")
  if err != nil {
    panic(err)
  }
  fmt.Println("Your username is: ", username)
}

Nous avons donc une instance crud connectée à la base de données MySQL via la variable d'environnement DATABASE_URL. Si nous exécutons ce programme, nous verrons une ligne de sortie :

$ DATABASE_URL=root:123456@/testdb go run example.go
Your username is: azer

Comme je l'ai déjà mentionné, la journalisation est silencieuse par défaut. Jetons un coup d'œil aux journaux internes de Crud : 

$ LOG=crud go run example.go
22:56:29.691 crud(0): SQL Query Executed: SELECT username FROM user WHERE email='[email protected]'
Your username is: azer

C'est simple et suffisant pour que nous puissions voir comment la requête est exécutée dans notre environnement de développement.

Logger est conçu pour la gestion de la configuration des « systèmes de journalisation internes » au niveau de l'application. Cela signifie que vous pouvez faire circuler les journaux bruts dans Slack en configurant l'enregistreur au niveau de votre application :

import (
  "github.com/azer/logger"
  "github.com/azer/logger-slack-hook"
)
func init () {
  logger.Hook(&slackhook.Writer{
    WebHookURL: "https://hooks.slack.com/services/...",
    Channel: "slow-queries",
    Username: "Query Person",
    Filter: func (log *logger.Log) bool {
      return log.Package == "mysql" && log.Level == "TIMER" && log.Elapsed >= 250
    }
  })
}

Dans le code ci-dessus :

Nous avons importé les bibliothèques logger et logger-slack-hook.
Nous configurons les journaux de l'enregistreur pour qu'ils soient transmis à Slack. Cette configuration couvre toutes les utilisations du logger dans la base de code, y compris les dépendances tierces.
Nous avons utilisé un filtre de flux pour afficher uniquement les journaux de minuterie du package MySQL qui durent plus de 250 ms.
Cette utilisation peut être étendue au-delà du simple reporting de requêtes lentes. Personnellement, je l'utilise pour suivre les erreurs importantes dans les packages spécifiés, ainsi que pour des statistiques telles que les connexions de nouveaux utilisateurs ou les journaux de génération de paiements.

crud

enregistreur

enregistreur-slack-crochet

Dites-nous si vous avez des questions ou des suggestions

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!