Diffusion en flux et affichage en direct des dernières lignes d'entrées de journal

Ce document explique comment afficher vos entrées de journal en temps réel en streaming et en affichage des dernières lignes en direct. La diffusion des journaux vous permet d'afficher les entrées de journal en temps réel. Elle est disponible dans l'explorateur de journaux. L'affichage en direct des dernières lignes vous permet d'afficher les entrées de journal en temps réel. Il est disponible avec la commande gcloud CLI gcloud alpha logging tail et avec la méthode d'API Cloud Logging entries.tail.

Lorsque vous affichez et analysez vos journaux à l'aide de l'explorateur de journaux, de gcloud logging read ou de la méthode d'API entries.list, vous consultez les entrées de journal que Cloud Logging a déjà stockées. Lorsque vous diffusez des entrées de journal en flux continu ou en direct, vous pouvez afficher les entrées dès que vos applications les écrivent dans l'API Cloud Logging.

Diffuser des journaux dans l'explorateur de journaux

Dans l'explorateur de journaux, vous pouvez afficher les données de vos journaux en temps réel grâce à la Diffusion des journaux. Lorsque vous utilisez la Diffusion des journaux, vous pouvez ajouter une requête pour ne diffuser que les journaux correspondant à la requête. Pour diffuser des journaux, procédez comme suit:

1. Dans la console Google Cloud, accédez à la page Explorateur de journaux.

   Accéder à l'explorateur de journaux

   Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Logging.

2. Dans la zone de texte Query (Requête), saisissez une requête, puis cliquez sur Stream logs (Flux de journaux).

   Lorsque Logging écrit les données de journalisation, seuls les journaux correspondant à la requête sont affichés dans le volet Résultats de la requête. Si aucune requête n'est fournie, Logging affiche les entrées de journal récemment stockées. La diffusion des journaux continue jusqu'à ce que vous sélectionniez la barre de défilement du panneau des journaux. Lorsque la diffusion est arrêtée, un bouton Redémarrer la diffusion s'affiche.

   Pour en savoir plus sur les requêtes, consultez la page Créer des requêtes dans l'explorateur de journaux.

Utiliser le affichage des dernières lignes en direct dans la Google Cloud CLI

L'affichage en direct des dernières lignes vous permet d'afficher vos entrées de journal en temps réel pendant que Cloud Logging les écrit à l'aide de Google Cloud CLI ou de l'API Cloud Logging.

L'affichage des dernières lignes en direct n'est pas compatible avec les buckets de journaux disposant de contrôles d'accès au niveau du champ. Toutefois, vous pouvez lire en streaming les journaux de ces buckets dans l'explorateur de journaux.

Pour plus d'informations sur la méthode API pour l'affichage en direct des dernières lignes, consultez la méthode entries.tail.

Installer gcloud alpha logging tail

Pour utiliser gcloud alpha logging tail, vous devez avoir installé Python 3 et le package Python grpcio.

Pour savoir comment installer Python, consultez la page Python. Pour savoir comment installer le gestionnaire de packages Python pip et comment installer le package grpcio, consultez la page Programme d'installation de packages Python.

Pour installer gcloud alpha logging tail, procédez comme suit :

1. Vérifiez que vous avez installé Google Cloud CLI. Pour savoir comment installer Google Cloud CLI, consultez la page Installer Google Cloud CLI.

2. Vérifiez que vous utilisez la version 302.0.0 ou ultérieure de la gcloud CLI.

   gcloud version
   

   Pour obtenir des instructions sur la mise à jour de gcloud CLI, consultez gcloud components update.

3. Installez les composants alpha de gcloud CLI:

   gcloud components install alpha
   

4. Pour les utilisateurs de macOS, Linux et Cloud Shell :

   1. Installez les bibliothèques clientes gRPC :

       sudo pip3 install grpcio
      

   2. Définissez la variable d'environnement CLOUDSDK_PYTHON_SITEPACKAGES sur n'importe quelle valeur :

       export CLOUDSDK_PYTHON_SITEPACKAGES=1
      

5. Exécutez les commandes suivantes pour définir l'ID de votre projet Google Cloud et vous authentifier:

   gcloud config set project PROJECT_ID
   gcloud auth login
   

   Pour obtenir l'ID du projet, consultez la section Créer et gérer des projets.

6. Vérifiez que gcloud alpha logging tail est installé en exécutant la commande suivante :

   gcloud alpha logging tail
   

   La commande affiche le message suivant:

   Initializing tail session.

   Vous consultez maintenant les entrées de journal de votre projet Google Cloud au fur et à mesure qu'elles sont écrites par Logging.

   

Pour plus d'informations sur l'utilisation de l'affichage en direct des dernières lignes, consultez le guide de référence sur gcloud alpha logging tail.

Mise en mémoire tampon et tri

Étant donné que Logging peut recevoir des entrées de journal ne respectant pas l'ordre chronologique, l'affichage en direct des dernières lignes fournit un paramètre de fenêtre de tampon qui vous permet d'équilibrer le compromis entre l'affichage des entrées de journal dès leur écriture et leur affichage dans l'ordre chronologique. Vous pouvez définir la fenêtre de tampon entre 0 et 60 secondes.

Notez les caractéristiques suivantes de la fenêtre de tampon :

• La fenêtre de tampon par défaut est de deux secondes.

• Logging retarde l'écriture des entrées de journal dans les buckets de journaux pendant la durée de la fenêtre de tampon.

• Si une entrée de journal est écrite en dehors de la fenêtre de tampon, Logging renvoie les entrées de journal au fur et à mesure de leur réception.

Lors de la configuration de la fenêtre de tampon, vous devez faire un compromis entre l'affichage des journaux dès l'écriture et leur affichage dans le désordre.

Limites et quotas

Le tableau suivant répertorie les limites et les quotas pour l'affichage en direct des dernières lignes :

Limites des clients

Si un projet Google Cloud écrit rapidement de nombreuses entrées, votre client risque de ne pas pouvoir les consommer aussi rapidement qu'elles sont écrites. Dans ce cas, Logging limite le nombre total d'entrées envoyées, en privilégiant les entrées les plus récentes. À la fin de la session d'affichage en direct des dernières lignes, Logging renvoie le nombre d'entrées qui n'ont pas été affichées en raison des limites du client.

Utiliser l'affichage des dernières lignes en direct avec des bibliothèques clientes

L'affichage en direct des dernières lignes vous permet d'afficher vos entrées de journal en temps réel à mesure que Cloud Logging les écrit. Pour plus d'informations sur la méthode API pour l'affichage en direct des dernières lignes, consultez la méthode entries.tail.

L'affichage des dernières lignes en direct n'est pas compatible avec les buckets de journaux disposant de contrôles d'accès au niveau du champ. Toutefois, vous pouvez lire en streaming les journaux de ces buckets dans l'explorateur de journaux.

Cet exemple fait la démonstration de l'affichage en direct des entrées de journal pour un enregistreur donné.

import (
	"context"
	"fmt"
	"io"

	logging "cloud.google.com/go/logging/apiv2"
	"cloud.google.com/go/logging/apiv2/loggingpb"
)

// tailLogs creates a channel to stream log entries that were recently ingested for a project
func tailLogs(projectID string) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	client, err := logging.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient error: %w", err)
	}
	defer client.Close()

	stream, err := client.TailLogEntries(ctx)
	if err != nil {
		return fmt.Errorf("TailLogEntries error: %w", err)
	}
	defer stream.CloseSend()

	req := &loggingpb.TailLogEntriesRequest{
		ResourceNames: []string{
			"projects/" + projectID,
		},
	}
	if err := stream.Send(req); err != nil {
		return fmt.Errorf("stream.Send error: %w", err)
	}

	// read and print two or more streamed log entries
	for counter := 0; counter < 2; {
		resp, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("stream.Recv error: %w", err)
		}
		fmt.Printf("received:\n%v\n", resp)
		if resp.Entries != nil {
			counter += len(resp.Entries)
		}
	}
	return nil
}

import com.google.cloud.logging.LogEntry;
import com.google.cloud.logging.LogEntryServerStream;
import com.google.cloud.logging.Logging;
import com.google.cloud.logging.Logging.TailOption;
import com.google.cloud.logging.LoggingOptions;

public class TailLogEntries {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Optionally provide the logname as an argument.
    String logName = args.length > 0 ? args[0] : "";

    LoggingOptions options = LoggingOptions.getDefaultInstance();
    try (Logging logging = options.getService()) {

      // Optionally compose a filter to tail log entries only from specific log
      LogEntryServerStream stream;

      if (logName != "") {
        stream =
            logging.tailLogEntries(
                TailOption.filter(
                    "logName=projects/" + options.getProjectId() + "/logs/" + logName));
      } else {
        stream = logging.tailLogEntries();
      }
      System.out.println("start streaming..");
      for (LogEntry log : stream) {
        System.out.println(log);
        // cancel infinite streaming after receiving first entry
        stream.cancel();
      }
    }
  }
}

const {Logging} = require('@google-cloud/logging');
const logging = new Logging();

/**
 * TODO(developer): Replace logName with the name of your log.
 */
const log = logging.log(logName);
console.log('running tail log entries test');

const stream = log
  .tailEntries({
    filter: 'timestamp > "2021-01-01T23:00:00Z"',
  })
  .on('error', console.error)
  .on('data', resp => {
    console.log(resp.entries);
    console.log(resp.suppressionInfo);
    // If you anticipate many results, you can end a stream early to prevent
    // unnecessary processing and API requests.
    stream.end();
  })
  .on('end', () => {
    console.log('log entry stream has ended');
  });

// Note: to get all project logs, invoke logging.tailEntries