Logging e visualizzazione dei log in Knative serving

Questa pagina descrive i log disponibili quando si utilizza Knative serving e come visualizzarli e scrivere i log.

Knative serving ha due tipi di log:

  • Log delle richieste: log delle richieste inviate ai servizi Knative serving. Questi log vengono creati automaticamente.
  • Log dei container: log emessi dalle istanze di container, in genere dalle il tuo codice, scritto nelle località supportate come descritto in Scrittura dei log dei container.

Abilitazione dei log

Per Google Cloud, i log vengono inviati automaticamente Cloud Logging. Per Google Distributed Cloud, devi prima abilitare i log.

Visualizzazione dei log

Puoi visualizzare i log relativi al tuo servizio in due modi:

  • Utilizzare la pagina Knative serving nella console Google Cloud
  • Utilizza Esplora log di Cloud Logging nella console Google Cloud.

Entrambi questi metodi di visualizzazione esaminano gli stessi log archiviati Cloud Logging, ma Esplora log di Cloud Logging fornisce più dettagli e più funzionalità di filtro.

Visualizzazione dei log in Knative serving

Per visualizzare i log nella pagina di Knative serving:

  1. Vai a Knative serving

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

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

Visualizzazione dei log in Cloud Logging

Per visualizzare i log di Knative serving in Esplora log di Cloud Logging:

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

  2. Seleziona un progetto Google Cloud esistente nella parte superiore della pagina oppure per creare un nuovo progetto.

  3. Dai 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 l'articolo IntelliJ e Visual Studio Code guide.

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

Quando scrivi i log dal tuo servizio, questi vengono raccolti automaticamente Cloud Logging purché i log siano scritti in uno qualsiasi di questi località:

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

I log dei container scritti in queste località supportate vengono automaticamente associati al servizio, alla revisione e alla località di Knative serving.

Utilizzo di testo semplice o JSON strutturato nei log

Quando scrivi i log, puoi inviare una semplice stringa di testo o una singola riga di JSON serializzato, chiamato anche "structured" e i dati di Google Cloud. Questo viene rilevato e analizzato da Cloud Logging e inserito in jsonPayload. Nel il contrasto, il semplice messaggio di testo viene inserito in textPayload.

Scrittura di log strutturati

Il seguente snippet mostra come scrivere voci di log strutturate. Inoltre, mostra come correlare i messaggi di log al corrispondente log delle richieste.

Node.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 

# 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))

Vai

La struttura di ogni voce di log è fornita da un tipo 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)
}

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


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 abilitando il encoder JSON Logstash nella configurazione logback.xml. 

// 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.
// For instantiating the "logger" variable, see
// https://cloud.google.com/run/docs/logging#run_manual_logging-java
logger.error(
    "This is the default display field.",
    kv("component", "arbitrary-property"),
    kv("severity", "NOTICE"),
    globalLogFields);
<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 rimosse da jsonPayload e vengono scritte nel campo corrispondente in la generazione LogEntry come descritto in la documentazione per i campi speciali.

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

Correlazione dei log dei container con un log delle richieste

In Esplora log, i log correlati allo stesso valore trace vengono visibile in "genitore-figlio" format: quando fai clic sul triangolo a sinistra della voce di log delle richieste, i log dei container relativi vengono visualizzate nidificate sotto il log delle richieste.

I log dei container non vengono correlati automaticamente ai log delle richieste, a meno che non utilizzi un 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 contiene un Campo logging.googleapis.com/trace con l'identificatore della traccia estratto da l'intestazione X-Cloud-Trace-Context, come mostrato nell'esempio sopra riportato per log strutturato.

Controllo dell'utilizzo delle risorse dei log delle richieste

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

Una nota sugli agenti di logging

Se hai utilizzato Cloud Logging con determinati prodotti Google Cloud, come Compute Engine, potresti aver utilizzato gli agenti di logging di Cloud Logging. Knative serving non utilizza gli agenti di logging perché ha il supporto integrato. per la raccolta dei log.

Risorsa di logging

Se fai clic su una voce di log in Esplora log, si apre un file JSON di voce di log formattata per consentirti di visualizzare i dettagli desiderati.

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

Tuttavia, esistono alcune etichette o etichette delle risorse speciali Knative serving. Di seguito vengono elencati i contenuti di esempio:

{
 httpRequest: {…}
 insertId:  "5c82b3d1000ece0000000000"
 labels: {
  instanceId:  "00bf4bf00000fb59c906a00000c9e29c2c4e06dce91500000000056008d2b6460f163c0057b97b2345f2725fb2423ee5f0bafd36df887fdb1122371563cf1ff453717282afe000001"
 }
 logName:  "projects/my-project/logs/anthos/run/.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 richieste, errore standard, output standard e così via.
configuration_name La risorsa di configurazione che ha creato la revisione che ha gestito la richiesta.
location Identifica la località Google Cloud del servizio.
project_id Il progetto in cui viene eseguito il deployment del servizio.
revision_name La revisione che ha gestito la richiesta.
service_name Il servizio che ha gestito la richiesta.
type cloud_run_revision. Il tipo di risorsa Knative serving.