Generazione e visualizzazione dei log in Cloud Run

Questa pagina descrive i log disponibili quando utilizzi Cloud Run e come visualizzarli e scriverli.

Cloud Run ha diversi tipi di log, che vengono inviati automaticamente a Cloud Logging:

• Log delle richieste (solo servizi): log delle richieste inviate ai servizi Cloud Run. Questi log vengono creati automaticamente.
• Log dei container (tutte le risorse): log emessi dalle istanze, in genere dal tuo codice, scritti nelle posizioni supportate come descritto in Scrittura dei log dei container.
• Log di sistema (tutte le risorse): log generati dalla piattaforma contenenti informazioni sui tuoi workload. Questi log vengono scritti in varlog/system.

Visualizza i log

Puoi visualizzare i log per la risorsa Cloud Run in diversi modi:

• Utilizzare la pagina Cloud Run nella console Cloud de Confiance
• Utilizzare Cloud Logging
• Utilizza Google Cloud CLI per visualizzare i log utilizzando gcloud (solo servizi)

Entrambi i metodi di visualizzazione dei log nella console esaminano gli stessi log archiviati in Cloud Logging, ma Esplora log di Cloud Logging fornisce maggiori dettagli e più funzionalità di filtro.

Visualizza i log in Cloud Run

Puoi visualizzare i log nella pagina Cloud Run per le seguenti risorse:

Formato e contenuti dei log di scalabilità dell'istanza

Quando vengono avviate nuove istanze per il servizio Cloud Run, Cloud Logging include voci di log con il nome log varlog/system che spiegano perché è stata creata ogni istanza. La voce di log segue questo formato:

Starting new instance. Reason: REASON - DESCRIPTION

La tabella seguente fornisce una suddivisione delle descrizioni delle istanze:

Scrivere log dei container

Quando scrivi i log dal tuo servizio, job o pool di worker, questi vengono rilevati automaticamente da Cloud Logging, a condizione che vengano scritti in una delle seguenti posizioni:

• Flussi di output standard (stdout) o di errore standard (stderr)
• Qualsiasi file nella directory /var/log
• syslog (/dev/log)
• Log scritti utilizzando le librerie client di Cloud Logging, disponibili per molti linguaggi popolari

La maggior parte degli sviluppatori deve scrivere i log utilizzando l'output standard e l'errore standard.

I log dei container scritti in queste posizioni supportate vengono associati automaticamente al servizio, alla revisione e alla posizione di Cloud Run, al pool di worker, alla revisione e alla posizione di Cloud Run o al job Cloud Run. Le eccezioni contenute in questi log vengono acquisite e segnalate in Error Reporting.

La registrazione integrata bilancia l'affidabilità e l'utilizzo delle risorse e dovrebbe funzionare per la maggior parte delle applicazioni. La scrittura di voci di log utilizzando la registrazione integrata non consuma la quota per il numero di richieste entries.write al minuto dell&#39API Cloud Loggingng.

Se la tua applicazione ha requisiti di volume o affidabilità più elevati, ti consigliamo di utilizzare direttamente l'API Cloud Logging, come libreria all'interno dell'applicazione o come container sidecar separato.

Utilizza testo semplice anziché JSON strutturato nei log

Quando scrivi i log, puoi inviare una semplice stringa di testo o una singola riga di JSON serializzato, chiamati anche dati "strutturati". Viene rilevato e analizzato da Cloud Logging e inserito in jsonPayload. Al contrario, il semplice messaggio di testo viene inserito in textPayload.

Scrittura di log strutturati

Il seguente snippet mostra come scrivere voci di log strutturate. Mostra anche come correlare i messaggi di log con il log delle richieste corrispondente.

// Uncomment and populate this variable in your code:
// const project = 'The project ID of your function or Cloud Run service';

// Build structured log messages as an object.
const globalLogFields = {};

// Add log correlation to nest all log messages beneath request log in Log Viewer.
// (This only works for HTTP-based invocations where `req` is defined.)
if (typeof req !== 'undefined') {
  const traceHeader = req.header('X-Cloud-Trace-Context');
  if (traceHeader && project) {
    const [trace] = traceHeader.split('/');
    globalLogFields['logging.googleapis.com/trace'] =
      `projects/${project}/traces/${trace}`;
  }
}

// Complete a structured log entry.
const entry = Object.assign(
  {
    severity: 'NOTICE',
    message: 'This is the default display field.',
    // Log viewer accesses 'component' as 'jsonPayload.component'.
    component: 'arbitrary-property',
  },
  globalLogFields
);

// Serialize to a JSON string and output.
console.log(JSON.stringify(entry));

# Uncomment and populate this variable in your code:
# PROJECT = 'The project ID of your Cloud Run service';

# Build structured log messages as an object.
global_log_fields = {}

# Add log correlation to nest all log messages.
# This is only relevant in HTTP-based contexts, and is ignored elsewhere.
# (In particular, non-HTTP-based Cloud Functions.)
request_is_defined = "request" in globals() or "request" in locals()
if request_is_defined and request:
    trace_header = request.headers.get("X-Cloud-Trace-Context")

    if trace_header and PROJECT:
        trace = trace_header.split("/")
        global_log_fields[
            "logging.googleapis.com/trace"
        ] = f"projects/{PROJECT}/traces/{trace[0]}"

# Complete a structured log entry.
entry = dict(
    severity="NOTICE",
    message="This is the default display field.",
    # Log viewer accesses 'component' as jsonPayload.component'.
    component="arbitrary-property",
    **global_log_fields,
)

print(json.dumps(entry))

// Entry defines a log entry.
type Entry struct {
	Message  string `json:"message"`
	Severity string `json:"severity,omitempty"`
	Trace    string `json:"logging.googleapis.com/trace,omitempty"`

	// Logs Explorer allows filtering and display of this as `jsonPayload.component`.
	Component string `json:"component,omitempty"`
}

// String renders an entry structure to the JSON format expected by Cloud Logging.
func (e Entry) String() string {
	if e.Severity == "" {
		e.Severity = "INFO"
	}
	out, err := json.Marshal(e)
	if err != nil {
		log.Printf("json.Marshal: %v", err)
	}
	return string(out)
}

func init() {
	// Disable log prefixes such as the default timestamp.
	// Prefix text prevents the message from being parsed as JSON.
	// A timestamp is added when shipping logs to Cloud Logging.
	log.SetFlags(0)
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	// Uncomment and populate this variable in your code:
	// projectID = "The project ID of your Cloud Run service"

	// Derive the traceID associated with the current request.
	var trace string
	if projectID != "" {
		traceHeader := r.Header.Get("X-Cloud-Trace-Context")
		traceParts := strings.Split(traceHeader, "/")
		if len(traceParts) > 0 && len(traceParts[0]) > 0 {
			trace = fmt.Sprintf("projects/%s/traces/%s", projectID, traceParts[0])
		}
	}

	log.Println(Entry{
		Severity:  "NOTICE",
		Message:   "This is the default display field.",
		Component: "arbitrary-property",
		Trace:     trace,
	})

	fmt.Fprintln(w, "Hello Logger!")
}

// Add log correlation to nest all log messages beneath request log in Log Viewer.
// TODO(developer): delete this code if you're creating a Cloud
//                  Function and it is *NOT* triggered by HTTP.
String traceHeader = req.headers("x-cloud-trace-context");
if (traceHeader != null && project != null) {
  String trace = traceHeader.split("/")[0];
  MDC.put(
      "logging.googleapis.com/trace",
      String.format("projects/%s/traces/%s", project, trace));
}
// -- End log correlation code --

// Create a structured log entry using MDC (Mapped Diagnostic Context) keys.
// For instantiating the "logger" variable, see
// https://cloud.google.com/run/docs/logging#run_manual_logging-java
MDC.put("component", "arbitrary-property");

logger.info("This is the default display field.");

// Clear MDC at the end of the request to avoid resource leaks
MDC.clear();

<configuration>
  <appender name="CLOUD" class="com.google.cloud.logging.logback.LoggingAppender">
    <!-- Optional : filter logs at or above a level -->
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
      <level>INFO</level>
    </filter>
    <log>application.log</log> <!-- Optional : default java.log -->
    <resourceType>gae_app</resourceType> <!-- Optional : default: auto-detected, fallback: global -->
    <enhancer>com.example.logging.logback.enhancers.ExampleEnhancer</enhancer> <!-- Optional -->
    <flushLevel>WARN</flushLevel> <!-- Optional : default ERROR -->
    <!-- Redirect logs to stdout in JSON format for Cloud Run to capture -->
    <redirectToStdout>true</redirectToStdout>
  </appender>
  <root level="INFO">
    <appender-ref ref="CLOUD"/>
  </root>
</configuration>

{"severity":"INFO","time":"YYYY-MM-DDTHH:MM:SS.SSSZ","logging.googleapis.com/labels":{"component":"arbitrary-property","levelName":"INFO","loggerName":"com.example.cloudrun.App","levelValue":"20000"},"logging.googleapis.com/trace_sampled":false,"message":"This is the default display field."}

Campi JSON speciali nei messaggi

Quando fornisci un log strutturato come dizionario JSON, alcuni campi speciali vengono rimossi da jsonPayload e scritti nel campo corrispondente della LogEntry generata, come descritto nella documentazione relativa ai campi speciali.

Ad esempio, se il file JSON include una proprietà severity, questa viene rimossa da jsonPayload e viene visualizzata come severity della voce di log. La proprietà message viene utilizzata come testo di visualizzazione principale della voce di log, se presente. Per saperne di più sulle proprietà speciali, leggi la sezione Risorsa di logging di seguito.

Correlare i log dei container con un log di richiesta (solo servizi)

In Esplora log, i log correlati dallo stesso trace sono visualizzabili in formato "principale-secondario": quando fai clic sull'icona a forma di triangolo a sinistra della voce di log delle richieste, i log dei container correlati a quella richiesta vengono visualizzati nidificati sotto il log delle richieste.

I log dei container non vengono correlati automaticamente ai log delle richieste, a meno che tu non utilizzi una libreria client di Cloud Logging. Per correlare i log dei container con i log delle richieste senza utilizzare una libreria client, puoi utilizzare una riga di log JSON strutturata che contenga un campo logging.googleapis.com/trace con l'identificatore di traccia estratto dall'intestazione X-Cloud-Trace-Context, come mostrato nell'esempio precedente per la registrazione strutturata.

Controllare l'utilizzo delle risorse di log delle richieste (solo servizi)

I log delle richieste vengono creati automaticamente. Sebbene non sia possibile controllare la quantità di log delle richieste direttamente da Cloud Run, puoi utilizzare la funzionalità di esclusione dei log di Cloud Logging.

Una nota sugli agenti Logging

Se hai utilizzato Cloud Logging con determinati prodotti Cloud de Confiance by S3NS , ad esempio Compute Engine, potresti aver utilizzato gli agenti di logging di Cloud Logging. Cloud Run non utilizza agenti di logging perché supporta la raccolta dei log.

Nomi delle risorse di logging

I nomi delle risorse di logging per Cloud Run sono:

• Revisione Cloud Run (cloud_run_revision).
• Cloud Run Job (cloud_run_job).

Risorse di logging

Se fai clic su una voce di log in Esplora log, si apre una voce di log formattata in JSON, in modo da poter esaminare in dettaglio le informazioni che ti interessano.

Tutti i campi di una voce di log, come timestamp, gravità e httpRequest sono standard e sono descritti nella documentazione di una voce di log.

Cloud Run aggiunge metadati aggiuntivi, in modo da poter identificare l'origine di un log. Ciò include le (etichette impostate sul servizio Cloud Run) e le etichette delle risorse specifiche di Cloud Run.

Campi delle voci di log per un servizio

Di seguito è riportato un elenco dei campi che possono essere trovati nella voce di log per un servizio Cloud Run:

Ecco un esempio di voce di log delle richieste per un servizio Cloud Run:

{
 httpRequest: {…}
 insertId:  "5c82b3d1000ece0000000000"
 labels: {
  instanceId:  "00bf4bf00000fb59c906a00000c9e29c2c4e06dce91500000000056008d2b6460f163c0057b97b2345f2725fb2423ee5f0bafd36df887fdb1122371563cf1ff453717282afe000001"
  mylabel: "mylabelvalue"
  mysecondlabel: "mysecondlabelvalue"
 }
 logName:  "projects/my-project/logs/run.googleapis.com%2Frequests"
 receiveTimestamp:  "2019-03-08T18:26:25.981686167Z"
 resource: {
  labels: {
   configuration_name:  "myservice"
   location:  "europe-west1"
   project_id:  "my-project"
   revision_name:  "myservice-00002"
   service_name:  "myservice"
  }
  type:  "cloud_run_revision"
 }
 severity:  "INFO"
 timestamp:  "2019-03-08T18:26:25.970397Z"
}

Campi delle voci di log per i job

Di seguito è riportato un elenco dei campi che si trovano nella voce di log di un job Cloud Run: