Esegui il deployment del Collector OpenTelemetry su Container-Optimized OS

Questo documento descrive come eseguire il collettore OpenTelemetry creato da Google su Container-Optimized OS per raccogliere log, metriche e tracce OTLP dalle applicazioni strumentate ed esportare i dati in Google Cloud.

Prima di iniziare

L'esecuzione di OpenTelemetry Collector richiede le seguenti risorse:

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

1. Una macchina virtuale (VM) Container-Optimized OS. Se non hai una VM Container-Optimized OS, segui le istruzioni riportate in Creazione e configurazione delle istanze.
2. Un'installazione di gcloud. Per informazioni sull'installazione di gcloud, consulta Installare Google Cloud CLI.

Configurare le autorizzazioni per il raccoglitore

Per impostazione predefinita, le VM Container-Optimized OS utilizzano l'account di servizio predefinito di Compute Engine,[e-mail]. Questo account di servizio di solito dispone dei ruoli Identity and Access Management (IAM) necessari per scrivere la telemetria descritta in questo documento:

• Monitoring Metric Writer (roles/monitoring.metricWriter)
• Logs Writer (roles/logging.logWriter)
• Cloud Trace Agent

Se stai configurando un account di servizio personalizzato per la tua istanza, consulta Gestire l'accesso ai service account.

Esegui il deployment del raccoglitore

Per eseguire Google-Built OpenTelemetry Collector, devi fornire un file di configurazione per la tua VM Container-Optimized OS. Puoi utilizzare lo strumento cloud-init per scrivere un file di configurazione. Di seguito è riportato un file cloud-init consigliato per l'utilizzo dell'agente di raccolta creato da Google:

write_files:
- path: /etc/config/config.yaml
  permissions: 0644
  owner: root
  content: |
    receivers:
      # Open two OTLP servers:
      # - On port 4317, open an OTLP GRPC server
      # - On port 4318, open an OTLP HTTP server
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
      otlp:
        protocols:
          grpc:
            endpoint: localhost:4317
          http:
            cors:
              # This effectively allows any origin
              # to make requests to the HTTP server.
              allowed_origins:
              - http://*
              - https://*
            endpoint: localhost:4318

    processors:
      # The batch processor is in place to regulate both the number of requests
      # being made and the size of those requests.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
      batch:
        send_batch_max_size: 200
        send_batch_size: 200
        timeout: 5s

      # The memorylimiter will check the memory usage of the collector process.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
      memory_limiter:
        check_interval: 1s
        limit_percentage: 65
        spike_limit_percentage: 20

      # The resourcedetection processor is configured to detect GCP resources.
      # Resource attributes that represent the GCP resource the collector is
      # running on will be attached to all telemetry that goes through this
      # processor.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
      resourcedetection:
        detectors: [gcp]
        timeout: 10s

      # The resource/gcp_project_id processor sets the GCP project ID attribute on telemetry data exported via OTLP.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourceprocessor
      resource/gcp_project_id:
        attributes:
        - action: insert
          key: gcp.project_id
          value: ${GOOGLE_CLOUD_PROJECT}

      # The metricstarttime processor sets start time on delta metrics for OTLP export.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/metricstarttimeprocessor
      metricstarttime:
        strategy: subtract_initial_point

      transform/collision:
        metric_statements:
        - context: datapoint
          statements:
          - set(attributes["exported_location"], attributes["location"])
          - delete_key(attributes, "location")
          - set(attributes["exported_cluster"], attributes["cluster"])
          - delete_key(attributes, "cluster")
          - set(attributes["exported_namespace"], attributes["namespace"])
          - delete_key(attributes, "namespace")
          - set(attributes["exported_job"], attributes["job"])
          - delete_key(attributes, "job")
          - set(attributes["exported_instance"], attributes["instance"])
          - delete_key(attributes, "instance")
          - set(attributes["exported_project_id"], attributes["project_id"])
          - delete_key(attributes, "project_id")

      # For each Prometheus unknown-typed metric, which is a gauge, create a counter that is an exact copy of this metric.
      # The GCP OTLP endpoint will add appropriate suffixes for the counter and gauge.
      transform/prometheus_unknown_types:
        error_mode: ignore
        metric_statements:
        - context: metric
          statements:
          - copy_metric(Concat([metric.name, "unknowncounter"], ":")) where metric.metadata["prometheus.type"] == "unknown" and not HasSuffix(metric.name, ":unknowncounter")
          - convert_gauge_to_sum("cumulative", true) where HasSuffix(metric.name, ":unknowncounter")
          - set(metric.name, Substring(metric.name, 0, Len(metric.name)-Len(":unknowncounter"))) where HasSuffix(metric.name, ":unknowncounter")

      transform/otlp_grpc/preserve_instrumentation_source_version:
        error_mode: ignore
        log_statements:
        - context: log
          statements:
          - set(attributes["instrumentation_source"], instrumentation_scope.name) where instrumentation_scope.name != ""
          - set(attributes["instrumentation_version"], instrumentation_scope.version) where instrumentation_scope.version != ""

      transform/otlp_grpc/copy_service_resource_labels:
        error_mode: ignore
        log_statements:
        - context: log
          statements:
          - set(attributes["service.name"], resource.attributes["service.name"]) where resource.attributes["service.name"] != nil
          - set(attributes["service.namespace"], resource.attributes["service.namespace"]) where resource.attributes["service.namespace"] != nil
          - set(attributes["service.instance.id"], resource.attributes["service.instance.id"]) where resource.attributes["service.instance.id"] != nil

    exporters:
      # The otlp_grpc exporter is used to send telemetry (logs, metrics, traces) to GCP Telemetry API using OTLP gRPC.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter
      otlp_grpc:
        endpoint: telemetry.googleapis.com:443
        balancer_name: pick_first
        auth:
          authenticator: googleclientauth

    extensions:
      googleclientauth:

    service:
      extensions:
      - googleclientauth
      pipelines:
        logs:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - transform/otlp_grpc/preserve_instrumentation_source_version
          - transform/otlp_grpc/copy_service_resource_labels
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
        metrics/otlp:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - transform/collision
          - transform/prometheus_unknown_types
          - metricstarttime
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
        traces:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
      # Internal telemetry for the collector supports both push and pull-based telemetry data transmission.
      # Leveraging the pre-configured OTLP receiver eliminates the need for an additional port.
      #
      # Docs:
      # https://opentelemetry.io/docs/collector/internal-telemetry/
      telemetry:
        metrics:
          readers:
            - periodic:
                exporter:
                  otlp:
                    protocol: grpc
                    endpoint: http://localhost:4317
                    insecure: true

Ti consigliamo di creare una rete Docker bridge per facilitare la comunicazione tra il container Collector e qualsiasi altro container sul sistema che invierà la telemetria. Per creare la rete, esegui questo comando:

docker network create -d bridge otel

Esegui il container Collector con il seguente comando:

docker run -d \
    --network otel \
    --name opentelemetry-collector \
    -v /etc/config:/etc/config \
    us-docker.pkg.dev/cloud-ops-agents-artifacts/google-cloud-opentelemetry-collector/otelcol-google:0.160.0 \
    --config=/etc/config/config.yaml

Il comando precedente esegue le seguenti operazioni:

• Esegue il container Collector in background.
• Collega il container Collector alla rete bridge otel creata in precedenza. Altri contenitori possono essere collegati al bridge per inviare dati di telemetria.
• Monta il file di configurazione sul container in modo che possa essere accessibile per configurare il raccoglitore.

Nota: il valore dell'opzione --name, opentelemetry-collector, viene utilizzato nella sezione successiva Genera telemetria. Se modifica il valore in questo comando, utilizza il tuo valore quando imposti il segnaposto opentelemetry-collector in questa sezione.

Configura il raccoglitore

Forniamo una configurazione di OpenTelemetry Collector da utilizzare con il Collector creato da Google. Questa configurazione è progettata per fornire volumi elevati di metriche, log e tracce OTLP. Questa configurazione è progettata anche per prevenire problemi comuni di importazione. Puoi aggiungere elementi alla configurazione, ma ti consigliamo vivamente di non rimuovere elementi.

Questa sezione descrive la configurazione fornita, i componenti chiave come esportatori, processori, ricevitori e altri componenti disponibili.

Configurazione del raccoglitore fornita

Puoi trovare la configurazione del raccoglitore nella directory google-built-opentelemetry-collector del repository opentelemetry-operations-collector:

receivers:
  # Open two OTLP servers:
  # - On port 4317, open an OTLP GRPC server
  # - On port 4318, open an OTLP HTTP server
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
  otlp:
    protocols:
      grpc:
        endpoint: localhost:4317
      http:
        cors:
          # This effectively allows any origin
          # to make requests to the HTTP server.
          allowed_origins:
          - http://*
          - https://*
        endpoint: localhost:4318

processors:
  # The batch processor is in place to regulate both the number of requests
  # being made and the size of those requests.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  # The memorylimiter will check the memory usage of the collector process.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  # The resourcedetection processor is configured to detect GCP resources.
  # Resource attributes that represent the GCP resource the collector is
  # running on will be attached to all telemetry that goes through this
  # processor.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  # The resource/gcp_project_id processor sets the GCP project ID attribute on telemetry data exported via OTLP.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourceprocessor
  resource/gcp_project_id:
    attributes:
    - action: insert
      key: gcp.project_id
      value: ${GOOGLE_CLOUD_PROJECT}

  # The metricstarttime processor sets start time on delta metrics for OTLP export.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/metricstarttimeprocessor
  metricstarttime:
    strategy: subtract_initial_point

  transform/collision:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["exported_location"], attributes["location"])
      - delete_key(attributes, "location")
      - set(attributes["exported_cluster"], attributes["cluster"])
      - delete_key(attributes, "cluster")
      - set(attributes["exported_namespace"], attributes["namespace"])
      - delete_key(attributes, "namespace")
      - set(attributes["exported_job"], attributes["job"])
      - delete_key(attributes, "job")
      - set(attributes["exported_instance"], attributes["instance"])
      - delete_key(attributes, "instance")
      - set(attributes["exported_project_id"], attributes["project_id"])
      - delete_key(attributes, "project_id")

  # For each Prometheus unknown-typed metric, which is a gauge, create a counter that is an exact copy of this metric.
  # The GCP OTLP endpoint will add appropriate suffixes for the counter and gauge.
  transform/prometheus_unknown_types:
    error_mode: ignore
    metric_statements:
    - context: metric
      statements:
      - copy_metric(Concat([metric.name, "unknowncounter"], ":")) where metric.metadata["prometheus.type"] == "unknown" and not HasSuffix(metric.name, ":unknowncounter")
      - convert_gauge_to_sum("cumulative", true) where HasSuffix(metric.name, ":unknowncounter")
      - set(metric.name, Substring(metric.name, 0, Len(metric.name)-Len(":unknowncounter"))) where HasSuffix(metric.name, ":unknowncounter")

  transform/otlp_grpc/preserve_instrumentation_source_version:
    error_mode: ignore
    log_statements:
    - context: log
      statements:
      - set(attributes["instrumentation_source"], instrumentation_scope.name) where instrumentation_scope.name != ""
      - set(attributes["instrumentation_version"], instrumentation_scope.version) where instrumentation_scope.version != ""

  transform/otlp_grpc/copy_service_resource_labels:
    error_mode: ignore
    log_statements:
    - context: log
      statements:
      - set(attributes["service.name"], resource.attributes["service.name"]) where resource.attributes["service.name"] != nil
      - set(attributes["service.namespace"], resource.attributes["service.namespace"]) where resource.attributes["service.namespace"] != nil
      - set(attributes["service.instance.id"], resource.attributes["service.instance.id"]) where resource.attributes["service.instance.id"] != nil

exporters:
  # The otlp_grpc exporter is used to send telemetry (logs, metrics, traces) to GCP Telemetry API using OTLP gRPC.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter
  otlp_grpc:
    endpoint: telemetry.googleapis.com:443
    balancer_name: pick_first
    auth:
      authenticator: googleclientauth

extensions:
  # Opens an endpoint on 13133 that can be used to check the
  # status of the collector. Since this does not configure the
  # `path` config value, the endpoint will default to `/`.
  #
  # When running on Cloud Run, this extension is required and not optional.
  # In other environments it is recommended but may not be required for operation
  # (i.e. in Container-Optimized OS or other GCE environments).
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/healthcheckextension
  health_check:
    endpoint: 0.0.0.0:13133
  googleclientauth:

service:
  extensions:
  - health_check
  - googleclientauth
  pipelines:
    logs:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - transform/otlp_grpc/preserve_instrumentation_source_version
      - transform/otlp_grpc/copy_service_resource_labels
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
    metrics/otlp:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - transform/collision
      - transform/prometheus_unknown_types
      - metricstarttime
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
    traces:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
  # Internal telemetry for the collector supports both push and pull-based telemetry data transmission.
  # Leveraging the pre-configured OTLP receiver eliminates the need for an additional port.
  #
  # Docs:
  # https://opentelemetry.io/docs/collector/internal-telemetry/
  telemetry:
    metrics:
      readers:
        - periodic:
            exporter:
              otlp:
                protocol: grpc
                endpoint: http://localhost:4317
                insecure: true

Esportatori

La configurazione del raccoglitore utilizza quanto segue:

• L'esportatore gRPC OTLP, per inviare log, metriche e tracce all'API Telemetry (OTLP).
• googleclientauthextension per l'autenticazione API.

Processori

La configurazione dell'agente di raccolta include i seguenti processori:

• batch: Configurato per raggruppare le richieste di telemetria al Google Cloud numero massimo di voci per richiesta o all' Google Cloud intervallo minimo di 5 secondi (a seconda di quale si verifica per prima).

• memory_limiter: Limita la memoria utilizzata dall'agente di raccolta per evitare arresti anomali per out of memory eliminando i punti dati quando il limite viene superato.

• resourcedetection: Rileva automaticamente le etichette delle risorse Google Cloud , ad esempio project_id.

Ricevitori

La configurazione del raccoglitore include solo il ricevitore otlp. Per informazioni sull'instrumentazione delle applicazioni per inviare tracce e metriche OTLP all'endpoint OTLP dell'agente di raccolta, consulta Scegliere un approccio di instrumentazione.

Componenti disponibili

Il raccoglitore OpenTelemetry creato da Google contiene i componenti di cui la maggior parte degli utenti avrà bisogno per attivare un'esperienza avanzata in Google Cloud Observability. Per un elenco completo dei componenti disponibili, consulta Componenti nel repository opentelemetry-operations-collector.

Per richiedere modifiche o aggiunte ai componenti disponibili, apri una richiesta di funzionalità nel repository opentelemetry-operations-collector.

Genera dati di telemetria

Puoi testare la tua configurazione utilizzando lo strumento telemetrygen open source. Il progetto OpenTelemetry fornisce un container nel registro dei container GitHub.

Prima di eseguire i seguenti comandi, sostituisci i seguenti segnaposto, se hai modificato i valori predefiniti utilizzati nei comandi Docker in Deployment dell'agente di raccolta:

• otel: il nome specificato durante la creazione della rete Docker bridge.
• opentelemetry-collector: il nome specificato durante l'esecuzione del container.

Generare log

Per generare log utilizzando lo strumento telemetrygen, esegui questo comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  logs --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Generare metriche

Per generare metriche utilizzando lo strumento telemetrygen, esegui il seguente comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  metrics --otlp-insecure --rate=0.1 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Generare tracce

Per generare tracce utilizzando lo strumento telemetrygen, esegui il seguente comando:

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  traces --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Dopo alcuni minuti, la telemetria generata dall'applicazione inizia a fluire tramite l'agente di raccolta alla console Google Cloud per ogni indicatore.

Visualizzare la telemetria

Il raccoglitore OpenTelemetry creato da Google invia metriche, log e tracce dalle applicazioni strumentate a Google Cloud Observability. L'agente di raccolta invia anche metriche di auto-osservabilità. Le sezioni seguenti descrivono come visualizzare questa telemetria.

Visualizzare le metriche

L'agente di raccolta OpenTelemetry integrato in Google raccoglie le metriche Prometheus che puoi visualizzare utilizzando Esplora metriche. Le metriche raccolte dipendono dall'instrumentazione dell'app, anche se l'agente di raccolta creato da Google scrive anche alcune metriche proprie.

Per visualizzare le metriche raccolte da Google-Built OpenTelemetry Collector, segui questi passaggi:

1. Nella console Google Cloud , vai alla pagina  Esplora metriche:

   Vai a Esplora metriche

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

2. Nella barra degli strumenti della console Google Cloud , seleziona il tuo progetto Google Cloud . Per le configurazioni di App Hub, seleziona il progetto host di App Hub o il progetto di gestione della cartella app.
3. Nell'elemento Metrica, espandi il menu Seleziona una metrica, digita Prometheus Target nella barra dei filtri e poi utilizza i sottomenu per selezionare un tipo di risorsa e una metrica specifici:
   1. Nel menu Risorse attive, seleziona Target Prometheus.
   2. Per selezionare una metrica, utilizza i menu Categorie di metriche attive e Metriche attive. Le metriche raccolte da Google-Built OpenTelemetry Collector hanno il prefisso prometheus.googleapis.com.
   3. Fai clic su Applica.

4. Per aggiungere filtri, che rimuovono le serie temporali dai risultati della query, utilizza l'elemento Filtro.

5. Configura la modalità di visualizzazione dei dati.
   

   Quando le misurazioni di una metrica sono cumulative, Metrics Explorer normalizza automaticamente i dati misurati in base al periodo di allineamento, il che comporta la visualizzazione di una frequenza nel grafico. Per maggiori informazioni, consulta Tipi, tipi e conversioni.

   Quando vengono misurati valori interi o doppi, ad esempio con le metriche counter, Metrics Explorer somma automaticamente tutte le serie temporali. Per modificare questo comportamento, imposta il primo menu della voce Aggregazione su Nessuna.

   Per ulteriori informazioni sulla configurazione di un grafico, consulta Seleziona le metriche durante l'utilizzo di Esplora metriche.

Visualizza le tracce

Per visualizzare i dati di traccia:

1. Nella console Google Cloud , vai alla pagina Esplora tracce:

   Vai a Esplora tracce

   Puoi trovare questa pagina anche utilizzando la barra di ricerca.

2. Nella barra degli strumenti della console Google Cloud , seleziona il tuo progetto Google Cloud . Per le configurazioni di App Hub, seleziona il progetto host di App Hub o il progetto di gestione.
3. Nella sezione della tabella della pagina, seleziona una riga.

4. Nel grafico di Gantt nel riquadro Dettagli su Trace, seleziona un intervallo.

   Si apre un riquadro che mostra informazioni sulla richiesta tracciata. Questi dettagli includono il metodo, il codice di stato, il numero di byte e lo user agent del chiamante.

5. Per visualizzare i log associati a questa traccia, seleziona la scheda Log ed eventi.

   La scheda mostra i singoli log. Per visualizzare i dettagli della voce di log, espandila. Puoi anche fare clic su Visualizza log e visualizzare il log utilizzando Esplora log.

Per ulteriori informazioni sull'utilizzo di Esplora tracce, consulta Trovare ed esplorare le tracce.

Visualizza i log

Da Esplora log puoi esaminare i log e visualizzare le tracce associate, se esistenti.

1. Nella console Google Cloud , vai alla pagina segmento Esplora log:

   Vai a Esplora log

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Logging.

2. Individua una voce di log dell'app strumentata. Per visualizzare i dettagli, espandi la voce di log.

3. Fai clic su Trace in una voce di log con un messaggio di traccia, quindi seleziona Visualizza dettagli traccia.

   Si apre un riquadro Dettagli su Trace che mostra la traccia selezionata.

Per ulteriori informazioni sull'utilizzo di Esplora log, vedi Visualizza i log utilizzando Esplora log.

Osservare ed eseguire il debug del raccoglitore

Il raccoglitore OpenTelemetry integrato in Google fornisce automaticamente metriche di auto-osservabilità per aiutarti a monitorare le sue prestazioni e garantire il tempo di attività continuo della pipeline di importazione OTLP.

Per monitorare l'agente di raccolta, installa la dashboard di esempio per l'agente di raccolta. Questa dashboard offre informazioni sintetiche su diverse metriche del raccoglitore, tra cui uptime, utilizzo della memoria e chiamate API a Google Cloud Observability.

Per installare la dashboard:

1. Nella console Google Cloud , vai alla pagina  Dashboard:

   Vai a Dashboard

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

2. Fai clic su Modelli di dashboard.
3. Cerca la dashboard OpenTelemetry Collector.
4. (Facoltativo) Per visualizzare l'anteprima della dashboard, selezionala.

5. Fai clic su Aggiungi dashboard all'elenco e poi completa la finestra di dialogo.

   La finestra di dialogo ti consente di selezionare il nome della dashboard e aggiungere etichette alla dashboard.

Per saperne di più sull'installazione delle dashboard, vedi Installare un modello di dashboard.