Analiza un trabajo mediante registros

En esta página, se describe cómo habilitar y ver los registros de Cloud Logging para un trabajo.

Puedes usar los registros a fin de obtener información que sea útil para analizar tus trabajos. Por ejemplo, los registros pueden ayudarte a depurar trabajos con errores. Cuando Cloud Logging está habilitado para un trabajo, Cloud Logging genera los siguientes tipos de registros que puedes ver:

  • Registros de tareas (batch_task_logs): Registros de cualquier dato escrito en los flujos de salida estándar (stdout) y estándar (stderr). Si deseas generar registros de tareas para tu trabajo, configúralas a fin de escribir datos para analizarlos y depurarlos en estas transmisiones.
  • Registros de agentes (batch_agent_logs): Registros de actividades del agente de servicio de Batch Batch genera de forma automática estos registros para tu trabajo.

Ten en cuenta que Cloud Logging solo genera registros después de que comienza a ejecutarse un trabajo. Para verificar si un trabajo comenzó a ejecutarse, descríbelo y confirma que su estado sea RUNNING o un estado posterior. Si necesitas analizar un trabajo que no generó registros, por ejemplo, porque uno falló antes del estado RUNNING, descríbelo con la CLI de gcloud o la API de Batch y verifica el campo statusEvents.

Antes de comenzar

Habilitar los registros para un trabajo

Si deseas generar registros para un trabajo, habilita Cloud Logging cuando crees el trabajo:

  • Si creas un trabajo con la consola de Google Cloud, Cloud Logging siempre está habilitado.

  • Si creas un trabajo mediante la CLI de gcloud o la API de Batch, Cloud Logging estará inhabilitado de forma predeterminada. Para habilitar Cloud Logging, incluye la siguiente configuración para el campo logsPolicy mientras creas el trabajo:

    {
    ...
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
    ...
}

Ver los registros de un trabajo

Puedes ver los registros de un trabajo en Cloud Logging mediante la consola de Google Cloud, gcloud CLI, la API de Logging, Go, Java o Python.

Consola

Para ver los registros de un trabajo con la consola de Google Cloud, haz lo siguiente:

  1. En la consola de Google Cloud, ve a la página Lista de trabajos.

    Ir a la lista de trabajos

  2. En la columna Nombre del trabajo, haz clic en el nombre de un trabajo. Se abrirá la página Detalles del trabajo.

  3. Haga clic en la pestaña Eventos.

  4. En la sección Registros, haz clic en  Cloud Logging. Se abrirá la página Explorador de registros.

    De forma predeterminada, el Explorador de registros muestra todos los registros de tareas de este trabajo.

    Recomendado: Para filtrar qué registros se muestran, compila consultas. Por ejemplo, ingresa una consulta de registros por lotes en el campo de editor de consultas.

gcloud

Para ver los registros mediante gcloud CLI, usa el comando gcloud logging read:

gcloud logging read "QUERY"

En el comando anterior, QUERY es una consulta de registros por lotes.

API

Para ver los registros con la API de Logging, usa el método entries.list:

POST https://logging.googleapis.com/v2/entries:list
{
    "resourceNames": [
        "projects/PROJECT_ID"
    ],
    "filter": "QUERY"
    "orderBy": "timestamp desc"
}

Reemplaza lo siguiente:

Comienza a usarlo

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Go por lotes. 

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/logging"
	"cloud.google.com/go/logging/logadmin"
	"google.golang.org/api/iterator"
	batchpb "google.golang.org/genproto/googleapis/cloud/batch/v1"
)

// Retrieve the logs written by the given job to Cloud Logging
func printJobLogs(w io.Writer, projectID string, job *batchpb.Job) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer batchClient.Close()

	adminClient, err := logadmin.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("Failed to create logadmin client: %v", err)
	}
	defer adminClient.Close()

	const name = "batch_task_logs"

	iter := adminClient.Entries(ctx,
		// Only get entries from the "batch_task_logs" log for the job with the given UID
		logadmin.Filter(fmt.Sprintf(`logName = "projects/%s/logs/%s" AND labels.job_uid=%s`, projectID, name, job.Uid)),
	)

	var entries []*logging.Entry

	for {
		logEntry, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to fetch log entry: %v", err)
		}
		entries = append(entries, logEntry)
		fmt.Fprintf(w, "%s\n", logEntry.Payload)
	}

	fmt.Fprintf(w, "Successfully fetched %d log entries\n", len(entries))

	return nil
}

Java

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Java por lotes. 


import com.google.cloud.batch.v1.Job;
import com.google.cloud.logging.v2.LoggingClient;
import com.google.logging.v2.ListLogEntriesRequest;
import com.google.logging.v2.LogEntry;
import java.io.IOException;

public class ReadJobLogs {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project hosting the job.
    String projectId = "YOUR_PROJECT_ID";

    // The job which logs you want to print.
    Job job = Job.newBuilder().build();

    readJobLogs(projectId, job);
  }

  // Prints the log messages created by given job.
  public static void readJobLogs(String projectId, Job job) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `loggingClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (LoggingClient loggingClient = LoggingClient.create()) {

      ListLogEntriesRequest request = ListLogEntriesRequest.newBuilder()
          .addResourceNames(String.format("projects/%s", projectId))
          .setFilter(String.format("labels.job_uid=%s", job.getUid()))
          .build();

      for (LogEntry logEntry : loggingClient.listLogEntries(request).iterateAll()) {
        System.out.println(logEntry.getTextPayload());
      }
    }
  }
}

Python

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Python por lotes. 

from typing import NoReturn

from google.cloud import batch_v1
from google.cloud import logging

def print_job_logs(project_id: str, job: batch_v1.Job) -> NoReturn:
    """
    Prints the log messages created by given job.

    Args:
        project_id: name of the project hosting the job.
        job: the job which logs you want to print.
    """
    # Initialize client that will be used to send requests across threads. This
    # client only needs to be created once, and can be reused for multiple requests.
    log_client = logging.Client(project=project_id)
    logger = log_client.logger("batch_task_logs")

    for log_entry in logger.list_entries(filter_=f"labels.job_uid={job.uid}"):
        print(log_entry.payload)

Escribir consultas para filtrar los registros por lotes

Puedes filtrar los registros por lotes si escribes una consulta que incluya uno o más de los siguientes parámetros de filtro y cero o más operadores booleanos (AND, OR y NOT).

  • Para filtrar los registros de un trabajo específico, especifica el ID único (UID):

    labels.job_uid=JOB_UID

    En el comando anterior, JOB_UID es el UID del trabajo. Para obtener el UID de un trabajo, descríbelo.

  • Para filtrar un tipo específico de registros por lotes, especifica el tipo de registro:

    logName=projects/PROJECT_ID/logs/BATCH_LOG_TYPE

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto cuyos registros deseas ver.
    • BATCH_LOG_TYPE: Es el tipo de registros por lotes que deseas ver, ya sea batch_task_logs para los registros de tareas o batch_agent_logs para los registros de agentes.

¿Qué sigue?