Logging e visualizzazione log

Questa pagina descrive i log disponibili quando si utilizza Cloud Run for Anthos e come visualizzare e scrivere log.

Cloud Run for Anthos ha due tipi di log, che vengono inviati automaticamente a Cloud Logging:

  • Log delle richieste: log delle richieste inviate ai servizi Cloud Run for Anthos. Questi log vengono creati automaticamente.
  • Log dei container: log emessi dalle istanze di container, generalmente dal tuo codice, scritti in posizioni supportate come descritto in Scrittura dei log dei container.

Visualizzazione dei log

Puoi visualizzare i log per il tuo servizio in due modi:

  • Utilizza la pagina Cloud Run for Anthos nella console Google Cloud
  • Utilizzare Cloud Logging Logs Explorer nella console Google Cloud.

Entrambi i metodi di visualizzazione esaminano gli stessi log archiviati in Cloud Logging, ma Esplora log di Cloud Logging fornisce ulteriori dettagli e funzionalità di filtro.

Visualizzazione dei log in Cloud Run for Anthos

Per visualizzare i log nella pagina Cloud Run for Anthos:

  1. Vai a Cloud Run for Anthos

  2. Fai clic sul servizio desiderato nell'elenco visualizzato.

  3. Fai clic sulla scheda LOG per recuperare i log delle richieste e dei container per tutte le revisioni di questo servizio. Puoi filtrare in base al livello di gravità del log.

Visualizzazione dei log in Cloud Logging

Per visualizzare i log di Cloud Run for Anthos in Cloud Logging Logs Explorer:

  1. Vai alla pagina Esplora log nella console Google Cloud:

    Vai alla pagina Esplora log

  2. Seleziona un progetto Google Cloud esistente nella parte superiore della pagina, oppure crea un nuovo progetto.

  3. Utilizzando i menu a discesa, seleziona la risorsa: Container Kubernetes.

Per ulteriori informazioni, consulta Utilizzo di Esplora log.

Visualizzazione dei log in Cloud Code

Per visualizzare i log in Cloud Code, leggi le guide IntelliJ e Visual Studio Code.

Lettura dei log in modo programmatico

Se vuoi leggere i log in modo programmatico, puoi utilizzare uno di questi metodi:

Scrittura dei log dei container

I log che scrivi dal tuo servizio verranno recuperati automaticamente da Cloud Logging, a condizione che siano scritti in una delle seguenti località:

La maggior parte degli sviluppatori dovrebbe scrivere i log utilizzando output ed errore standard.

I log dei container scritti in queste località supportate vengono associati automaticamente al servizio, revisione e località Cloud Run for Anthos.

Utilizzare testo semplice e JSON strutturato nei log

Quando scrivi i log, puoi inviare una semplice stringa di testo o inviare una singola riga di dati JSON serializzati, chiamati anche dati "strutturati". che viene selezionato ed analizzato da Cloud Logging e posizionato in jsonPayload. Invece, il semplice SMS viene inserito in textPayload.

Scrittura di log strutturati

Lo snippet che segue mostra come scrivere voci di log strutturate. Mostra inoltre come correlare i messaggi di log con il log delle richieste corrispondente.

Node.js

run/logging-manual/app.js 

// 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));

Python

run/logging-manual/main.py 
# 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))

Go

La struttura per ogni voce di log è fornita da un tipo Entry:

run/logging-manual/main.go 

// 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)
}

Quando viene registrato uno struct Entry, il metodo String viene chiamato per il marshal nel formato JSON previsto da Cloud Logging:

run/logging-manual/main.go 

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!")
}

Java

Abilita il logging JSON con Logback e SLF4J attivando il Logstash JSON Encoder nella tua configurazione logback.xml.

run/logging-manual/src/main/java/com/example/cloudrun/App.java 
// Build structured log messages as an object.
Object globalLogFields = null;

// 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];
  globalLogFields =
      kv(
          "logging.googleapis.com/trace",
          String.format("projects/%s/traces/%s", project, trace));
}
// -- End log correlation code --

// Create a structured log entry using key value pairs.
logger.error(
    "This is the default display field.",
    kv("component", "arbitrary-property"),
    kv("severity", "NOTICE"),
    globalLogFields);
run/logging-manual/src/main/resources/logback.xml 
<configuration>
  <appender name="jsonConsoleAppender" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
      <!-- Ignore default logging fields -->
      <fieldNames>
        <timestamp>[ignore]</timestamp>
        <version>[ignore]</version>
        <logger>[ignore]</logger>
        <thread>[ignore]</thread>
        <level>[ignore]</level>
        <levelValue>[ignore]</levelValue>
      </fieldNames>
    </encoder>
  </appender>
  <root level="INFO">
    <appender-ref ref="jsonConsoleAppender"/>
  </root>
</configuration>

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 nella sezione LogEntry generata, come descritto nella documentazione per i campi speciali.

Ad esempio, se il file JSON include una proprietà severity, viene rimosso da jsonPayload e viene visualizzato come severity della voce di log. La proprietà message viene utilizzata come testo principale per la visualizzazione delle voci di log, se presente. Per ulteriori informazioni sulle proprietà speciali, consulta la sezione Risorsa di logging di seguito.

Correlare i log dei container con un log delle richieste

In Esplora log, i log correlati allo stesso trace sono visualizzabili nel formato "parent-child": quando fai clic sull'icona a forma di triangolo a sinistra della voce del log della richiesta, i log del container relativi alla richiesta vengono visualizzati nidificati nel log della richiesta.

I log dei container non sono correlati automaticamente ai log delle richieste a meno che non utilizzi una libreria client di Cloud Logging. Per mettere in relazione i log dei container con i log delle richieste senza utilizzare una libreria client, puoi utilizzare una riga di log JSON strutturata che contiene un campo logging.googleapis.com/trace con l'identificatore di traccia estratto dall'intestazione X-Cloud-Trace-Context, come mostrato nell'esempio sopra per il logging strutturato.

Controllo dell'utilizzo delle risorse dei log delle richieste

I log delle richieste vengono creati automaticamente. Anche se non puoi controllare la quantità di log delle richieste direttamente da Cloud Run for Anthos, puoi utilizzare la funzionalità di esclusione dei log da Cloud Logging.

Una nota sugli agenti di logging

Se hai utilizzato Cloud Logging con determinati prodotti Google Cloud, ad esempio Compute Engine, potresti aver usato gli agenti di logging di Cloud Logging. Cloud Run for Anthos non utilizza agenti di logging perché dispone di supporto integrato per la raccolta di log.

Risorsa di logging

Se fai clic su una voce di log in Esplora log, viene aperta una voce di log in formato JSON per visualizzare i dettagli in dettaglio.

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

Tuttavia, esistono alcune etichette o risorse speciali per Cloud Run for Anthos. Di seguito sono elencati i contenuti di esempio:

{
 httpRequest: {…}
 insertId:  "5c82b3d1000ece0000000000"
 labels: {
  instanceId:  "00bf4bf00000fb59c906a00000c9e29c2c4e06dce91500000000056008d2b6460f163c0057b97b2345f2725fb2423ee5f0bafd36df887fdb1122371563cf1ff453717282afe000001"
 }
 logName:  "projects/my-project/logs/anthos/run/archive/.googleapis.com%2Frequests"
 receiveTimestamp:  "2019-03-08T18:26:25.981686167Z"
 resource: {
  labels: {
   configuration_name:  "myservice"
   location:  "us-central1"
   project_id:  "my-project"
   revision_name:  "myservice-00002"
   service_name:  "myservice"
  }
  type:  "cloud_run_revision"
 }
 severity:  "INFO"
 timestamp:  "2019-03-08T18:26:25.970397Z"
}
Campo Valori e note
instanceId L'istanza di container che ha gestito la richiesta.
logName Identifica il log, ad esempio log delle richieste, errore standard, output standard e così via.
configuration_name La risorsa di configurazione che ha creato la revisione che ha fornito la richiesta.
location Identifica la località GCP del servizio.
project_id Il progetto in cui viene eseguito il deployment del servizio.
revision_name La revisione che ha pubblicato la richiesta.
service_name Il servizio che ha gestito la richiesta.
type cloud_run_revision. Il tipo di risorsa Cloud Run for Anthos.