Snowpark Container Services: Überwachen von Diensten¶

Verwenden der Funktion <service-name>!SPCS_GET_LOGS¶

Die Tabellenfunktion <service_name>!SPCS_GET_LOGS gibt Protokolle aus den Containern des angegebenen Jobs zurück. Diese Protokolle werden von Snowflake gesammelt und in der Ereignistabelle gespeichert.

Die folgende Liste erläutert die Vorteile der Verwendung dieser Tabellenfunktion:

• Sie können Protokolle für einen bestimmten Service abrufen.

• Sie können Protokolle innerhalb eines bestimmten Zeitbereichs abrufen.

• Der Aufrufer benötigt keinen Zugriff auf die gesamte Ereignistabelle, was für Kunden mit strengen Anforderungen an die Informationssicherheit von Vorteil sein kann. Wenn die aktuelle Sitzung die Eigentümerrolle für den Service enthält, dann hat sie Zugriff auf diese Protokolle.

Für service_name geben Sie den Namen des Service an. Die Funktion gibt Protokolle zurück, die Snowflake aus Containern dieses Service gesammelt hat (siehe Auf Containerprotokolle zugreifen).

Sie können optional einen Datumsbereich angeben. Standardmäßig gibt die Funktion Ein-Tages-Protokolle zurück. Die Abfrage hat beispielsweise Protokolle abgerufen, die Snowflake aus Containern des my_test_job-Job über den letzten Tag gesammelt hat, was der Standard ist.

SELECT * FROM TABLE(my_test_job!SPCS_GET_LOGS());

Copy

Beispielausgabe:

+-------------------------+-------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+
| TIMESTAMP               | INSTANCE_ID | CONTAINER_NAME | LOG                                                                                                                                                                 | RECORD_ATTRIBUTES          |
|-------------------------+-------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------|
| 2025-06-26 00:23:40.281 |           0 | main           | job-tutorial - INFO - Job finished                                                                                                                                  | {                          |
|                         |             |                |                                                                                                                                                                     |   "log.iostream": "stdout" |
|                         |             |                |                                                                                                                                                                     | }                          |
| 2025-06-26 00:23:38.787 |           0 | main           | job-tutorial - INFO - Executing query [select current_time() as time,'hello'] and writing result to table [results]                                                 | {                          |
|                         |             |                |                                                                                                                                                                     |   "log.iostream": "stdout" |
|                         |             |                |                                                                                                                                                                     | }                          |
| 2025-06-26 00:23:38.787 |           0 | main           | job-tutorial - INFO - Connection succeeded. Current session context: database="TUTORIAL_DB", schema="DATA_SCHEMA", warehouse="TUTORIAL_WAREHOUSE", role="TEST_ROLE" | {                          |
|                         |             |                |                                                                                                                                                                     |   "log.iostream": "stdout" |
|                         |             |                |                                                                                                                                                                     | }                          |
| 2025-06-26 00:23:36.852 |           0 | main           | job-tutorial - INFO - Job started                                                                                                                                   | {                          |
|                         |             |                |                                                                                                                                                                     |   "log.iostream": "stdout" |
|                         |             |                |                                                                                                                                                                     | }                          |
+-------------------------+-------------+----------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+

Weitere Informationen zum Aufrufen dieser Methode finden Sie unter <service_name>!SPCS_GET_LOGS.

Verwenden der Ereignistabelle¶

Snowflake kann Protokolle, die von Containern an die Standardausgabe und die Standardfehlerstreams gesendet werden, in der für Ihr Konto konfigurierten Ereignistabelle erfassen. Weitere Informationen zur Konfiguration einer Ereignistabelle finden Sie unter Protokollierung, Ablaufverfolgung und Metriken.

Über das Feld spec.logExporters in der Datei der Dienstspezifikation steuern Sie, welche Datenstreams gesammelt werden (alle, nur Standardfehler oder keine), die Sie in einer Ereignistabelle speichern möchten.

Sie können dann die Ereignistabelle nach Ereignissen abfragen. Um die aktive Ereignistabelle für das Konto zu finden, verwenden Sie den Befehl SHOW PARAMETERS, um den Wert des Parameters EVENT_TABLE zu ermitteln:

SHOW PARAMETERS LIKE 'event_table' IN ACCOUNT;

Der Parameter gibt die aktive Ereignistabelle für das Konto an.

Als Nächstes fragen Sie diese Ereignistabelle ab. Die folgende SELECT-Anweisung ruft Snowflake Dienst- und Jobereignisse ab, die in der letzten Stunde aufgezeichnet wurden:

SELECT TIMESTAMP, RESOURCE_ATTRIBUTES, RECORD_ATTRIBUTES, VALUE
FROM <current_event_table_for_your_account>
WHERE timestamp > dateadd(hour, -1, current_timestamp())
AND RESOURCE_ATTRIBUTES:"snow.service.name" = '<service_name>'
AND RECORD_TYPE = 'LOG'
ORDER BY timestamp DESC
LIMIT 10;

Snowflake empfiehlt, einen Zeitstempel in die WHERE-Klausel von Ereignistabellenabfragen aufzunehmen, wie in diesem Beispiel gezeigt. Dies ist besonders wichtig wegen der potenziellen Datenmenge, die von verschiedenen Snowflake-Komponenten generiert wird. Durch die Anwendung von Filtern können Sie eine kleinere Teilmenge von Daten abrufen, was die Abfrageleistung verbessert.

Die Ereignistabelle enthält die folgenden Spalten, die nützliche Informationen zu den von Snowflake erfassten Protokolleinträgen zu Ihrem Container bereitstellen:

• TIMESTAMP: Zeigt an, wann Snowflake das Protokoll erfasst hat.

• RESOURCE_ATTRIBUTES: Stellt ein JSON-Objekt zur Verfügung, das den Snowflake-Dienst und den Container im Dienst, der die Meldung erzeugt hat, bezeichnet. Er gibt beispielsweise Details wie den Dienstnamen, den Containernamen und den Namen des Computepools an, die bei Ausführung des Dienstes angegeben wurden.

  {
    "snow.account.name": "SPCSDOCS1",
    "snow.compute_pool.id": 20,
    "snow.compute_pool.name": "TUTORIAL_COMPUTE_POOL",
    "snow.compute_pool.node.id": "a17e8157",
    "snow.compute_pool.node.instance_family": "CPU_X64_XS",
    "snow.database.id": 26,
    "snow.database.name": "TUTORIAL_DB",
    "snow.schema.id": 212,
    "snow.schema.name": "DATA_SCHEMA",
    "snow.service.container.instance": "0",
    "snow.service.container.name": "echo",
    "snow.service.container.run.id": "b30566",
     "snow.service.id": 114,
    "snow.service.name": "ECHO_SERVICE2",
    "snow.service.type": "Service"
  }
  

  Copy

• RECORD_ATTRIBUTES: Gibt für einen Snowflake-Dienst die Fehlerquelle an (Standardausgabe oder Standardfehler).

  { "log.iostream": "stdout" }
  

  Copy

• VALUE: Standardausgabe und Standardfehler sind in Zeilen unterteilt, und jede Zeile generiert einen Datensatz in der Ereignistabelle.

  "echo-service [2023-10-23 17:52:27,429] [DEBUG] Sending response: {'data': [[0, 'Joe said hello!']]}"
  

Verwenden von SYSTEM$GET_SERVICE_LOGS¶

Die Funktion SYSTEM$GET_SERVICE_LOGS gibt Protokolle des aktuell laufenden Service-Containers zurück. Nach dem Beenden eines Containers können Sie noch eine kurze Zeit lang mithilfe der Systemfunktion auf die Protokolle zugreifen. Systemfunktionen sind am nützlichsten während der Entwicklungs- und Testphase, wenn Sie einen neuen Dienst oder Job entwickeln.

Sie geben den Dienstnamen, die Instanz-ID, den Containernamen und optional die Anzahl der letzten Protokollzeilen an, die abgerufen werden sollen. Wenn nur eine Dienstinstanz ausgeführt wird, ist die Dienstinstanz-ID 0. Der folgende Befehl ruft beispielsweise die nachstehenden 10 Zeilen aus dem Protokoll eines Containers namens echo ab, der zur Instanz 0 eines Dienstes namens echo_service gehört:

SELECT SYSTEM$GET_SERVICE_LOGS('echo_service', '0', 'echo', 10);

Beispielausgabe:

+--------------------------------------------------------------------------+
| SYSTEM$GET_SERVICE_LOGS                                                  |
|--------------------------------------------------------------------------|
| 10.16.6.163 - - [11/Apr/2023 21:44:03] "GET /healthcheck HTTP/1.1" 200 - |
| 10.16.6.163 - - [11/Apr/2023 21:44:08] "GET /healthcheck HTTP/1.1" 200 - |
| 10.16.6.163 - - [11/Apr/2023 21:44:13] "GET /healthcheck HTTP/1.1" 200 - |
| 10.16.6.163 - - [11/Apr/2023 21:44:18] "GET /healthcheck HTTP/1.1" 200 - |
+--------------------------------------------------------------------------+
1 Row(s) produced. Time Elapsed: 0.878s

Wenn Sie nicht über die Informationen über den Service verfügen, die Sie zum Aufrufen der Funktion benötigen (wie z. B. die Instanz ID oder den Containernamen), können Sie zunächst den SHOW SERVICE CONTAINERS IN SERVICE-Befehl ausführen, um Informationen über die Service-Instanzen und Container zu erhalten, die in jeder Instanz laufen.

Die Funktion SYSTEM$GET_SERVICE_LOGS hat die folgenden Beschränkungen:

• Es führt die Standardausgabe und die Standardfehlerstreams zusammen. Die Funktion gibt keinen Hinweis darauf, von welchem Stream die Ausgabe stammt.

• Sie berichtet die erfassten Daten für einen bestimmten Container in einer einzigen Dienstinstanz.

• Sie werden nur Protokolle für einen in Ausführung befindlichen Container berichtet. Die Funktion kann keine Protokolle aus einem früheren Container abrufen, der neu gestartet wurde, oder aus einem Container eines Service, der eingestellt oder gelöscht wurde.

• Die Funktion gibt bis zu 100 KB an Daten zurück.

Zugriff auf Ereignistabelle für Dienstmetriken¶

Um Metriken aus einem Service in der für Ihr Konto konfigurierten Ereignistabelle zu protokollieren, nehmen Sie den folgenden Abschnitt in Ihre Dienstspezifikation auf:

platformMonitor:
  metricConfig:
    groups:
    - <group 1>
    - <group 2>
    - ...

Dabei verweist jedes group N auf eine vordefinierte Metrikgruppe, an der Sie interessiert sind (z. B. system, network oder storage). Weitere Informationen finden Sie im Abschnitt spec.platformMonitor field in der Dokumentation zur Dienstspezifikation.

Während der Dienst ausgeführt wird, protokolliert Snowflake diese Metriken in der Ereignistabelle in Ihrem Konto. Sie können diese Metriken auf folgende Weise lesen:

• Die Service-Hilfsmethode verwenden: Die Tabellenfunktion <service_name>!SPCS_GET_METRICS gibt Metriken zurück, die Snowflake für den angegebenen Dienst gesammelt hat. Die folgende Liste erläutert die Vorteile der Verwendung dieser Tabellenfunktion:

  • Sie können Metriken für einen bestimmten Service abrufen.

  • Sie können Metriken innerhalb eines bestimmten Zeitbereichs abrufen.

  • Der Aufrufer benötigt keinen Zugriff auf die gesamte Ereignistabelle, was für Kunden mit strengen Anforderungen an die Informationssicherheit von Vorteil sein kann.

  Die folgende SELECT-Anweisung verwendet die Tabellenfunktion, um Plattformereignisse für den angegebenen Service abzurufen, die in der letzten Stunde aufgezeichnet wurden:

  SELECT *
    FROM TABLE(echo_service!SPCS_GET_METRICS(start_time => dateadd('hour', -1, current_timestamp())));
  

  Copy

• Die Ereignistabelle direkt abfragen: Sie können Ihre Ereignistabelle abfragen, um die Metriken zu lesen. Die folgende Abfrage ruft die Dienstmetriken ab, die in der letzten Stunde für den my_service-Service aufgezeichnet wurden:

  SELECT timestamp, value
    FROM my_event_table_db.my_event_table_schema.my_event_table
    WHERE timestamp > DATEADD(hour, -1, CURRENT_TIMESTAMP())
      AND RESOURCE_ATTRIBUTES:"snow.service.name" = 'MY_SERVICE'
      AND RECORD_TYPE = 'METRIC'
      ORDER BY timestamp DESC
      LIMIT 10;
  

  Copy

  Wenn Sie den Namen der aktiven Ereignistabelle für das Konto nicht kennen, führen Sie den SHOW PARAMETERS-Befehl aus, um den Wert des Parameters EVENT_TABLE auf Kontoebene anzuzeigen:

  SHOW PARAMETERS LIKE 'event_table' IN ACCOUNT;
  

  Copy

  Weitere Informationen zu Ereignistabellen finden Sie unter Verwenden der Ereignistabelle.

Beispiel

Um einen Beispielservice zu erstellen, der Metriken in der Ereignistabelle aufzeichnet, die für Ihr Konto konfiguriert ist, führen Sie die folgenden Schritte aus:

1. Erstellen Sie einen Service namens echo_service, indem Sie die Schritte im Tutorial 1 mit einer Änderung ausführen. In Schritt 3, in dem Sie einen Service erstellen, verwenden Sie den folgenden Befehl CREATE SERVICE, um das Feld platformMonitor in die geänderte Service-Spezifikation einzufügen.

   CREATE SERVICE echo_service
     IN COMPUTE POOL tutorial_compute_pool
     FROM SPECIFICATION $$
       spec:
         containers:
         - name: echo
           image: /tutorial_db/data_schema/tutorial_repository/my_echo_service_image:latest
           env:
             SERVER_PORT: 8000
             CHARACTER_NAME: Bob
           readinessProbe:
             port: 8000
             path: /healthcheck
         endpoints:
         - name: echoendpoint
           port: 8000
           public: true
         platformMonitor:
           metricConfig:
             groups:
             - system
             - system_limits
         $$
       MIN_INSTANCES=1
       MAX_INSTANCES=1;
   

   Copy

Nachdem der Service läuft, beginnt Snowflake mit der Aufzeichnung der Metriken in den angegebenen Metrikgruppen in der Ereignistabelle.

1. Greifen Sie auf die Metriken durch Aufrufen der Funktion <service_name>!SPCS_GET_METRICS oder durch Abfrage der Ereignistabelle zu. Rufen Sie beispielsweise die in der letzten Stunde vom Dienst echo_service gemeldeten Metriken ab:

   • Die Hilfsfunktion <service_name>!SPCS_GET_METRICS verwenden:

     Copy

     SELECT * FROM TABLE(echo_service!SPCS_GET_METRICS(START_TIME => DATEADD(‚hour‘, -1, CURRENT_TIMESTAMP())));

   • Die Ereignistabelle direkt abfragen:

     SELECT timestamp, value
      FROM my_events
      WHERE timestamp > DATEADD(hour, -1, CURRENT_TIMESTAMP())
        AND RESOURCE_ATTRIBUTES:"snow.service.name" = 'ECHO_SERVICE'
        AND RECORD_TYPE = 'METRIC'
        AND RECORD:metric.name = 'container.cpu.usage'
        ORDER BY timestamp DESC
        LIMIT 100;
     

     Copy

Auf Computepool-Metriken zugreifen¶

Computepool-Metriken bieten Einblicke in die Knoten im Computepool und die darauf laufenden Dienste. Jeder Knoten meldet knotenspezifische Metriken, wie z. B. die Menge an verfügbarem Speicher für Container, sowie Dienstmetriken, wie z. B. die Speichernutzung durch einzelne Container. Die Computepool-Metriken liefern Informationen aus der Sicht eines Knotens.

Jeder Knoten hat einen Metrik-Verleger, der TCP-Port 9001 überwacht. Andere Dienste können eine HTTP GET-Anfrage mit dem Pfad /metrics an Port 9001 auf dem Knoten stellen. Um die IP-Adresse des Knotens zu ermitteln, rufen Sie SRV-Datensätze (oder A-Datensätze) von DNS für den Hostnamen discover.monitor.compute_pool_name.cp.spcs.internal ab. Dann erstellen Sie einen weiteren Dienst in Ihrem Konto, der jeden Knoten aktiv abfragt, um die Metriken abzurufen.

Der Hauptteil (Body) der Antwort liefert die Metriken unter Verwendung des Prometheus-Formats wie in den folgenden Beispielmetriken gezeigt:

# HELP node_memory_capacity Defines SPCS compute pool resource capacity on the node
# TYPE node_memory_capacity gauge
node_memory_capacity{snow_compute_pool_name="MY_POOL",snow_compute_pool_node_instance_family="CPU_X64_S",snow_compute_pool_node_id="10.244.3.8"} 1
node_cpu_capacity{snow_compute_pool_name="MY_POOL",snow_compute_pool_node_instance_family="CPU_X64_S",snow_compute_pool_node_id="10.244.3.8"} 7.21397383168e+09

Beachten Sie Folgendes:

• Der Body der Antwort beginnt mit # HELP und # TYPE, die eine kurze Beschreibung und den Typ der Metrik enthalten. In diesem Beispiel ist die node_memory_capacity-Metrik vom Typ gauge.

• Danach folgen der Name der Kennzahl, eine Liste von Bezeichnungen (Labels), die eine bestimmte Ressource (Datenpunkt) beschreiben, sowie ihr Wert. In diesem Beispiel liefert die Metrik (mit dem Namen node_memory_capacity) Informationen zum Arbeitsspeicher und zeigt an, dass der Knoten über 7,2 GB verfügbaren Arbeitsspeicher verfügt. Die Metrik enthält auch Metadaten in Form von Beschriftungen, wie gezeigt:

  snow_compute_pool_name="MY_POOL",
  snow_compute_pool_node_instance_family="CPU_X64_S",snow_compute_pool_node_id="10.244.3.8"
  

Sie können diese Metriken auf jede beliebige Weise verarbeiten. Sie können die Metriken beispielsweise in einer Datenbank speichern und ein UI (wie ein Grafana Dashboard) verwenden, um die Informationen anzuzeigen.

Eine Liste der verfügbaren Computepool-Metriken finden Sie unter Verfügbare Plattformmetriken.

Beispiel

Ein Beispiel für die Konfiguration von Prometheus zur Abfrage von Metriken in Ihrem Computepool finden Sie in den Tutorials zu Computepool-Metriken.

Verfügbare Plattformmetriken¶

Im Folgenden finden Sie eine Auflistung der verfügbaren Gruppen von Plattformmetriken und der Metriken innerhalb jeder Gruppe. Beachten Sie, dass die Speicher Metriken derzeit nur von Blockspeicher-Volumes erfasst werden.

Veröffentlichung von OTLP-Anwendungsmetriken und Ablaufverfolgungen¶

Snowflake führt einen OTel-Sammler aus, den Ihr Dienstcontainer verwenden kann, um OTLP-Anwendungsmetriken und Ablaufverfolgungen zu veröffentlichen. Das heißt, dass ein Dienstcontainer Metriken an die Endpunkte der OTel-Sammler senden kann, die Snowflake dann zusammen mit den Details des verursachenden Dienstes in die für Ihr Snowflake-Konto konfigurierte Ereignistabelle schreibt.

Dies funktioniert wie folgt:

• Snowflake füllt automatisch die folgenden Umgebungsvariablen in Ihrem Dienstcontainer aus, die die Endpunkte des OTel-Sammlers bereitstellen, an denen Container Anwendungsmetriken und Ablaufverfolgungen veröffentlichen können.

  • OTEL_EXPORTER_OTLP_METRICS_ENDPOINT

  • OTEL_EXPORTER_OTLP_TRACES_ENDPOINT

• Der Standard OTLP-Client sucht nach diesen Umgebungsvariablen, um den OTel-Sammler automatisch zu finden. Dies ermöglicht es Ihrem Dienstcontainer, Metriken und Ablaufverfolgungen über diesen Client zu veröffentlichen.

from opentelemetry.sdk.trace import TracerProvider
from snowflake.telemetry.trace import SnowflakeTraceIdGenerator


trace_id_generator = SnowflakeTraceIdGenerator()
tracer_provider = TracerProvider(
    resource=Resource.create({"service.name": SERVICE_NAME}),
    id_generator=trace_id_generator
)

import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
import com.snowflake.telemetry.trace.SnowflakeTraceIdGenerator;

static OpenTelemetry initOpenTelemetry() {
  return AutoConfiguredOpenTelemetrySdk.builder()
      .addPropertiesSupplier(
          () ->
              Map.of(...config options...)
      .addTracerProviderCustomizer(
          (tracerProviderBuilder, configProperties) -> {
            tracerProviderBuilder.setIdGenerator(SnowflakeTraceIdGenerator.INSTANCE);
            return tracerProviderBuilder;
          })
      .build()
      .getOpenTelemetrySdk();

Veröffentlichung von Prometheus-Anwendungsmetriken¶

Snowflake unterstützt Prometheus-Metriken. Anstatt OTLP-Metriken zu pushen, kann Ihre Anwendung Prometheus-Metriken bereitstellen, die von einem von Snowflake bereitgestellten Sammler abgefragt werden. Damit Snowflake diese Anwendungsmetriken von Ihrem Dienst erfassen und in der Ereignistabelle veröffentlichen kann, führen Sie folgende Schritte aus:

• Lassen Sie Ihren Dienst auf einem Port lauschen, der Ihre Prometheus-Metriken offenlegt.

• Binden Sie in Ihren Dienst einen von Snowflake bereitgestellten Container (auch als „Sidecar“-Container bezeichnet) mit der notwendigen Konfiguration ein, um die Metriken aus Ihrem Dienstcontainer zu ziehen.

Der Prometheus-Sidecar holt die Anwendungsmetriken in einem geplanten Rhythmus aus dem Container, konvertiert das Prometheus-Format in das OTLP -Format und sendet die Metriken an den OTel-Sammler. Der OTel-Sammler veröffentlicht diese Metriken dann in der für Ihr Snowflake-Konto konfigurierten Ereignistabelle.

Sie fügen den Prometheus Sidecar-Container als weiteren Container zur Dienstspezifikation hinzu und fügen ein Argument hinzu, um den HTTP-Endpunkt anzugeben, der von Ihrem Container bereitgestellt wird, und zwar in folgendem Format:

localhost:{PORT}/{METRICS_PATH}, {SCRAPE_FREQUENCY}

Er gibt eine Port-Nummer, einen Pfad und die Häufigkeit an, mit der der Sidecar die Metriken abrufen soll.

Ein Beispiel für ein Fragment der Dienstspezifikation zeigt, dass der Sidecar-Container jede Minute Metriken von Ihrem Dienstcontainer von Port 8000 abruft und Metriken aus dem Pfad „/metrics“ zieht:

spec:
  containers:
  - name: <name>
    image: <image-name>
    .....
  - name: prometheus
    image: /snowflake/images/snowflake_images/monitoring-prometheus-sidecar:0.0.1
    args:
      - "-e"
      - "localhost:8000/metrics,1m"

Erläuterungen zu dieser Spezifikation:

• image ist das von Snowflake zur Verfügung gestellte Sidecar-Container-Image.

• args stellt die notwendige Konfiguration für den Prometheus-Container zum Scrapen von Metriken bereit:

  • Ab Port 8000, der von Ihrem Container bereitgestellt wird. Der Port wird in dieser Prometheus Container-Konfiguration benötigt.

  • Verwenden Sie den Pfad „/metrics“. Er ist optional. Wenn nicht angegeben, ist „/metrics“ der Standardpfad.

  • Jede Minute. Er ist optional. Wenn nicht angegeben, ist „1m“ der Standardwert.

  Wenn Sie die Standardeinstellungen verwenden, ist dies die entsprechende Konfiguration für das Scraping von Metriken:

  spec:
      ...
      args:
        - "-e"
        - "localhost:8000"
  

  Copy

Zugriff auf Anwendungsmetriken und Ablaufverfolgungen in der Ereignistabelle¶

Sie können die Ereignistabelle abfragen, um Anwendungsmetriken abzurufen. Die folgende Abfrage ruft die Anwendungsmetriken ab, die in der letzten Stunde gesammelt wurden.

SELECT timestamp, record:metric.name, value
  FROM <current_event_table_for_your_account>
  WHERE timestamp > dateadd(hour, -1, CURRENT_TIMESTAMP())
    AND resource_attributes:"snow.service.name" = <service_name>
    AND scope:"name" != 'snow.spcs.platform'
    AND record_type = 'METRIC'
  ORDER BY timestamp DESC
  LIMIT 10;

Weitere Informationen zu Ereignistabellen finden Sie unter Überblick über die Ereignisse. Sie können diese Metriken in Snowflake Dashboards visualisieren.

Sie können auch Ihre Ereignistabelle abfragen, um die Ablaufverfolgung der Anwendung einzusehen. Um beispielsweise Ablaufverfolgungen der letzten Stunde abzurufen, ersetzen Sie in der vorangegangenen Abfrage die Bedingung record_type wie folgt:

AND record_type = 'SPAN' OR record_type = 'SPAN_EVENT'

Ablaufverfolgungen können im Snowflake Trail viewer visualisiert werden.

Metriken und Ablaufverfolgungen enthalten sowohl benutzerdefinierte als auch von Snowflake definierte Attribute als Ressourcen- und Datensatzattribute. Beachten Sie, dass das Präfix snow. für von Snowflake generierte Attribute reserviert ist. Snowflake ignoriert benutzerdefinierte Attribute, die dieses Präfix verwenden. Eine Liste der von Snowflake definierten Attribute finden Sie unter Verfügbare Plattformmetriken.

Der Beispielcode ist sowohl in Python als auch in Java verfügbar und demonstriert die Instrumentierung einer Anwendung mit benutzerdefinierten Metriken und Ablaufverfolgungen unter Verwendung des OTLP SDK. Die Beispiele zeigen, wie Sie die Generierung von Snowflake Ablaufverfolgungs-ID für die Kompatibilität mit dem Snowflake Trail Viewer für Ablaufverfolgung konfigurieren.

Plattformereignisse abfragen¶

Nachdem Sie den Protokolliergrad für Ihre Ressource konfiguriert haben, zeichnet Snowflake die Plattformereignisse in der aktiven Ereignistabelle in Ihrem Snowflake-Konto auf. Sie können auf diese Ereignisse auf folgende Weise zugreifen:

• Die Service-Hilfsmethode verwenden: Die Tabellenfunktion <service_name>!SPCS_GET_EVENTS gibt Ereignisse zurück, die Snowflake aus den Containern des angegebenen Service gesammelt hat.

  Die folgende Liste erläutert die Vorteile der Verwendung dieser Tabellenfunktion:

  • Sie können Ereignisse für einen bestimmten Service abrufen.

  • Sie können Ereignisse innerhalb eines bestimmten Zeitbereichs abrufen.

  • Der Aufrufer benötigt keinen Zugriff auf die gesamte Ereignistabelle, was für Kunden mit strengen Anforderungen an die Informationssicherheit von Vorteil sein kann.

  Die folgende SELECT-Anweisung verwendet die Tabellenfunktion, um Plattformereignisse für den angegebenen Service abzurufen, die in der letzten Stunde aufgezeichnet wurden:

  SELECT *
  FROM TABLE(echo_service!SPCS_GET_EVENTS(START_TIME => DATEADD('hour', -1, CURRENT_TIMESTAMP())));
  

  Copy

• Die Ereignistabelle direkt verwenden: Sie können die Ereignistabelle direkt abfragen. Um die aktive Ereignistabelle für das Konto zu finden, verwenden Sie den Befehl SHOW PARAMETERS, um den Wert des Parameters EVENT_TABLE zu ermitteln:

  SHOW PARAMETERS LIKE 'event_table' IN ACCOUNT;
  

  Copy

  Der Parameter gibt die aktive Ereignistabelle für das Konto an.

  Als Nächstes fragen Sie diese Ereignistabelle ab. Die folgende SELECT-Anweisung ruft Plattformereignisse für den angegebenen Service ab, die in der letzten Stunde aufgezeichnet wurden:

  SELECT TIMESTAMP, RESOURCE_ATTRIBUTES, RECORD, VALUE
    FROM <your_event_table>
    WHERE TIMESTAMP > DATEADD(hour, -1, CURRENT_TIMESTAMP())
      AND RESOURCE_ATTRIBUTES:"snow.service.name" = '<your_service_name>'
      AND RECORD_TYPE = 'EVENT'
      AND SCOPE:"name" = 'snow.spcs.platform'
    ORDER BY TIMESTAMP DESC
    LIMIT 10;
  

  Copy

  Weitere Informationen zu Ereignistabellen finden Sie unter Verwenden der Ereignistabelle.

  Die folgenden Spalten der Ereignistabelle enthalten nützliche Informationen zu den Plattformereignissen:

  • TIMESTAMP: Zeigt an, wann das Ereignis erfasst wurde.

  • RESOURCE_ATTRIBUTES: Stellt ein JSON-Objekt mit Metadaten zur Quelle des Ereignisses bereit, z. B. ein Service, ein Container oder ein Computepool. Das folgende Beispiel für einen -Wert in der resource_attribute-Spalte identifiziert einen bestimmten Service, für den das Ereignis erfasst wird.

    {
      "snow.compute_pool.name": "TUTORIAL_COMPUTE_POOL",
      "snow.compute_pool.id": 123,
      "snow.database.name": "TUTORIAL_DB",
      "snow.database.id": 456,
      "snow.schema.name": "DATA_SCHEMA",
      "snow.schema.id": 789,
      "snow.service.container.name": "echo",
      "snow.service.name": "ECHO_SERVICE2",
      "snow.service.id": 212,
      "snow.service.type": "Service"
    }
    

    Copy

  • SCOPE: Gibt den Ursprung des Ereignisses an. Bei Plattformereignissen lautet der Name des Bereichs snow.spcs.platform, wie im folgenden Beispiel gezeigt:

    { "name": "snow.spcs.platform" }
    

    Copy

  • RECORD_TYPE: Für Plattformereignisse ist EVENT der RECORD_TYPE.

  • RECORD: Stellt Metadaten zu dem jeweiligen Ereignis bereit. Die folgenden Metadaten zeigen den Namen und den Schweregrad des Plattformereignisses:

    { "name": "CONTAINER.STATUS_CHANGE", "severity_text": "INFO" }
    

    Copy

  • VALUE: Liefert die Details zum Ereignis. Das folgende Beispiel zeigt den Status und eine Nachricht über den Status des Containers:

    { "message": "Running", "status": "READY" }
    

    Copy

Unterstützte Ereignisse¶

Derzeit unterstützt Snowflake nur die Ereignisse zur Änderung des Containerstatus.

In der folgenden Tabelle sind die Plattformereignisse aufgeführt, die Snowflake aufzeichnet. RECORD und VALUE in den Spaltennamen beziehen sich auf die Spalten in der Ereignistabelle (im vorangegangenen Abschnitt erläutert).