Tutorial: Erste Schritte mit Protokollierung und Ablaufverfolgung¶
Einführung¶
Dieses Tutorial führt in die Grundlagen des Ausgebens, Sammelns und Abfragens von Protokoll- und Ablaufverfolgungsdaten aus Handler-Code von Funktionen und Prozeduren ein.
In dem Tutorial wird die Weboberfläche Snowsight verwendet, aber Sie können jeden Snowflake-Client verwenden, der die Ausführung von SQL unterstützt. Weitere Informationen zu Snowsight finden Sie unter Erste Schritte mit Arbeitsblättern und Verwalten und Verwenden von Arbeitsblättern in Snowsight.
Lerninhalte¶
In diesem Tutorial erfahren Sie Folgendes:
Erstellen einer Ereignistabelle zum Speichern von Protokoll- und Ablaufverfolgungsdaten.
Snowflake sammelt Protokoll- und Ablaufverfolgungsdaten in der vordefinierten Struktur der Tabelle.
Ausgeben von Protokollmeldungen und Protokoll- und Ablaufverfolgungsdaten mit einer benutzerdefinierten Funktion (UDF).
Sie können einen API verwenden, die für Ihre Handler-Sprache entwickelt wurde, um Protokollmeldungen und Ablaufverfolgungsdaten mit Handler-Code auszugeben.
Anzeigen der gesammelten Protokoll- und Ablaufverfolgungsdaten durch Abfragen der Ereignistabelle.
Sie können die Tabelle mit einer SELECT-Anweisung abfragen, um die gesammelten Daten zu analysieren.
Voraussetzungen¶
Sie müssen alle SQL-Befehle in der gleichen SQL-Befehlssitzung ausführen, da der Sitzungskontext erforderlich ist.
Bei Verwendung von Snowsight fügen Sie beispielsweise Ihren gesamten Code nach und nach in dasselbe Arbeitsblatt ein. Während Sie von Abschnitt zu Abschnitt vorankommen, baut jeder Abschnitt auf dem vorherigen auf.
Sie müssen die Rolle ACCOUNTADMIN verwenden können.
In diesem Tutorial werden Sie alle Schritte mit der Rolle ACCOUNTADMIN durchführen. In der Regel sollten Sie jedoch Rollen verwenden, deren Berechtigungen speziell für die von Ihnen auszuführende Aktion definiert sind. So können Sie beispielsweise separate Rollen für Entwickler verwenden, die UDFs erstellen, für Analysten, die gesammelte Protokoll- und Ablaufverfolgungsdaten abfragen, und so weiter.
Weitere Informationen zu Rollen finden Sie unter Aktive Rolle umschalten und Hinweise zur Zugriffssteuerung.
Einrichten von Datenbank, Warehouse und Zugriff¶
In diesem Abschnitt erstellen Sie ein Warehouse und eine Datenbank, die Sie für das Tutorial benötigen. Sie die Rolle ACCOUNTADMIN verwenden, die für das Ausführen einiger der Anweisungen in diesem Tutorial erforderlich ist.
Sie erstellen eine Datenbank, in der Sie später die Ereignistabelle und die benutzerdefinierte Funktion erstellen werden. Sie können alle im Tutorial erstellten Objekte, einschließlich Datenbank und Warehouse, löschen, wenn Sie diese nicht mehr benötigen.
So erstellen Sie eine Datenbank und ein Warehouse zur Verwendung im Tutorial:
Melden Sie sich bei Snowsight an.
Öffnen Sie Projects » Worksheets.
Wählen Sie + » SQL Worksheet aus.
Benennen Sie das neue Arbeitsblatt in
Logging-tracing tutorial
um.Fügen Sie in das neue Arbeitsblatt folgende Anweisung zum Erstellen einer Datenbank ein, und führen Sie die Anweisung aus. Die neue Datenbank ist nur zur Verwendung in diesem Tutorial vorgesehen.
CREATE OR REPLACE DATABASE tutorial_log_trace_db;
Fügen Sie folgende Anweisung zum Erstellen eines Warehouses ein, und führen Sie die Anweisung aus. Das neue Warehouse ist nur zur Verwendung in diesem Tutorial vorgesehen.
CREATE OR REPLACE WAREHOUSE tutorial_log_trace_wh WAREHOUSE_TYPE = STANDARD WAREHOUSE_SIZE = XSMALL;
In diesem Abschnitt stellen Sie die Teile bereit, die Sie für das Tutorial benötigen. Im nächsten Abschnitt erstellen Sie eine Ereignistabelle zum Speichern von Protokoll- und Ablaufverfolgungsdaten.
Ereignistabelle erstellen¶
In diesem Abschnitt werden Sie eine Ereignistabelle erstellen. Wenn Ihr Handler-Code Protokollmeldungen und Ablaufverfolgungsdaten ausgibt, speichert Snowflake die ausgegebenen Daten in den Zeilen einer Ereignistabelle. Sie können die Ereignistabelle abfragen, um die Daten zu analysieren.
Sie müssen eine Ereignistabelle erstellen, um Protokoll- und Ablaufverfolgungsdaten zu sammeln. Eine Ereignistabelle verwendet immer die von Snowflake definierte vordefinierte Struktur.
Wichtig
Um diesen Abschnitt abzuschließen, müssen Sie in der Lage sein, die Rolle ACCOUNTADMIN zu verwenden, die erforderlich ist, um ein Konto so zu ändern, dass die neue Ereignistabelle die aktive Ereignistabelle des Kontos ist.
So erstellen Sie die Ereignistabelle und legen sie als aktive Ereignistabelle des Kontos fest:
Fügen Sie die folgende Anweisung zum Erstellen einer Ereignistabelle ein, und führen Sie die Anweisung aus.
CREATE OR REPLACE EVENT TABLE tutorial_event_table;
In dieser Tabelle wird Snowflake die Protokoll- und Ablaufverfolgungsdaten speichern.
Fügen Sie die folgende Anweisung ein, mit der das Konto so geändert wird, dass die von Ihnen erstellte Ereignistabelle die aktive Tabelle des Kontos ist, und führen Sie die Anweisung aus.
ALTER ACCOUNT SET EVENT_TABLE = tutorial_log_trace_db.public.tutorial_event_table;
Diese Anweisung legt die neue Ereignistabelle als die Tabelle fest, die Snowflake für das Speichern von Protokollmeldungen und Ablaufverfolgungsdaten von Handlern im aktuellen Konto verwenden soll. Ein Konto kann immer nur eine aktive Ereignistabelle haben.
In diesem Abschnitt haben Sie eine Ereignistabelle erstellt. Im nächsten Abschnitt beginnen Sie mit der Ausgabe von Protokollmeldungen, die Snowflake in der Tabelle speichert.
Protokollmeldungen ausgeben¶
In diesem Abschnitt werden Sie eine benutzerdefinierte Funktion (UDF) mit Python-Handler-Code erstellen, die Protokollmeldungen ausgibt. Wenn Ihr Code Protokollmeldungen ausgibt, sammelt Snowflake die Meldungsdaten und speichert sie in der von Ihnen erstellten Ereignistabelle.
Snowflake unterstützt APIs jeder unterstützten Handler-Sprache, um Meldungen zu protokollieren. Für Handler, die Sie in Python schreiben, können Sie das Modul logging
der Standardbibliothek von Python verwenden.
So erstellen Sie einen UDF, die Protokollmeldungen ausgibt:
Fügen Sie die folgende Anweisung ein, um den Protokolliergrad auf
INFO
festzulegen, und führen Sie die Anweisung aus.ALTER SESSION SET LOG_LEVEL = INFO;
Hier wird der Schweregrad der Protokollmeldungen angegeben, die Snowflake bei Ausführung der UDF erfassen soll. In diesem Fall lässt der Schweregrad alle Meldungen zu, von informativen (
INFO
) bis hin zu den schwerwiegendsten Ereignissen (FATAL
).Fügen Sie folgende Anweisung zum Erstellen einer benutzerdefinierten Funktion ein, und führen Sie die Anweisung aus.
CREATE OR REPLACE FUNCTION log_trace_data() RETURNS VARCHAR LANGUAGE PYTHON RUNTIME_VERSION = 3.8 HANDLER = 'run' AS $$ import logging logger = logging.getLogger("tutorial_logger") def run(): logger.info("Logging from Python function.") return "SUCCESS" $$;
Die hervorgehobenen Zeilen des Codes bewirken Folgendes:
Importieren des Python-Moduls
logging
, damit der Handler-Code es verwenden kann.Erstellen eines Loggers, der die Schnittstelle darstellt, die Ihr Code zum Protokollieren von Meldungen verwenden wird.
Protokollieren einer Meldung mit Protokolliergrad
INFO
.
Fügen Sie die folgende Anweisung zum Ausführen der soeben erstellten Funktion ein, und führen Sie die Anweisung aus.
SELECT log_trace_data();
Folgende Ausgabe wird erstellt: Darüber hinaus wurde beim Ausführen der Funktion eine Protokollmeldung ausgegeben, die Snowflake in der Ereignistabelle gesammelt hat.
-------------------- | LOG_TRACE_DATA() | -------------------- | SUCCESS | --------------------
In diesem Abschnitt haben Sie eine Protokollmeldung von einer UDF ausgegeben. Im nächsten Abschnitt werden Sie die Ereignistabelle abfragen, um Daten zu dieser Meldung abzurufen.
Protokollmeldungen abfragen¶
In diesem Abschnitt werden Sie die Ereignistabelle auf Protokollmeldungsdaten abfragen, die von der im vorherigen Abschnitt ausgeführten UDF ausgegeben wurden.
Bemerkung
Es kann einige Sekunden dauern, bis die vom Handler-Code ausgegebenen Protokoll- oder Ablaufverfolgungsdaten in der Ereignistabelle erfasst werden. Wenn Sie nicht sofort ein Ergebnis sehen, versuchen Sie es nach ein paar Sekunden erneut.
Snowflake verwendet vordefinierte Ereignistabellenspalten zum Sammeln und Speichern von Protokoll- und Ablaufverfolgungsdaten der folgenden Arten:
Daten, die Sie von Handler-Code ausgeben: Diese umfassen Protokollmeldungen und Ablaufverfolgungsdaten zu Ereignissen.
Sie finden diese Daten in Spalten wie RECORD_TYPE, RECORD, RECORD_ATTRIBUTES usw.
Daten zum Kontext: Diese umfassen kontextspezifische Daten zur Ausgabe der Protokoll- oder Ablaufverfolgungsdaten, wie Zeitstempel, Name der Handler-Methode, von der aus die Daten gesendet wurden, usw.
Sie finden diese Daten in Spalten wie RESOURCE_ATTRIBUTES, TIMESTAMP und SCOPE.
So fragen Sie die Ereignistabelle nach Protokollmeldungsdaten ab:
Fügen Sie die folgende Anweisung zum Abfragen der Ereignistabelle ein, und führen Sie die Anweisung aus.
SELECT TIMESTAMP AS time, RESOURCE_ATTRIBUTES['snow.executable.name'] as executable, RECORD['severity_text'] AS severity, VALUE AS message FROM tutorial_log_trace_db.public.tutorial_event_table WHERE RECORD_TYPE = 'LOG' AND SCOPE['name'] = 'tutorial_logger';
Einige Spalten enthalten strukturierte Daten, die als Schlüssel-Wert-Paare ausgedrückt werden. In dieser Abfrage geben Sie Attributschlüssel innerhalb einer Spalte an, indem Sie die Klammernotation wie z. B.
RECORD['severity_text']
verwenden.Sie verwenden auch die Klammernotation (
SCOPE['name']
), um anzugeben, dass Sie nur Spaltenwerte auswählen möchten, bei denen die Protokolleinträge mit dem Python-Loggertutorial_logger
ausgegeben werden, den Sie im Handler-Code erstellt haben.Zeigen Sie die Ausgabe an.
----------------------------------------------------------------------------------------------------------- | TIME | EXECUTABLE | SEVERITY | MESSAGE | ----------------------------------------------------------------------------------------------------------- | 2023-04-19 22:00:49 | "LOG_TRACE_DATA():VARCHAR(16777216)" | "INFO" | "Logging from Python function." | -----------------------------------------------------------------------------------------------------------
Die Ausgabe veranschaulicht, wie die vordefinierten Spalten der Ereignistabelle jeweils Teile der gesammelten Daten enthalten. Für die Werte von
EXECUTABLE
undSEVERITY
haben Sie die Klammernotation zur Angabe der Attribute verwendet, deren Werte Sie benötigen.Ausgabespalte
Beschreibung
TIME
Zeitpunkt der Erstellung des Eintrags (aus der Spalte TIMESTAMP).
EXECUTABLE
Name und Parameter der UDF (aus dem Attribut
snow.executable.name
der Spalte RESOURCE_ATTRIBUTES).SEVERITY
Schweregrad des Protokolleintrags (aus dem Attribut
severity_text
der Spalte RECORD).MESSAGE
Protokollmeldung (aus der Spalte VALUE).
In diesem Abschnitt haben Sie eine SELECT-Anweisung zur Abfrage von Protokolldaten verwendet. Im nächsten Abschnitt werden Sie die UDF so aktualisieren, dass sie Ablaufverfolgungsdaten ausgibt.
Ablaufverfolgungsdaten ausgeben¶
In diesem Abschnitt aktualisieren Sie den UDF-Handler-Code so, dass auch Ablaufverfolgungsdaten ausgegeben werden. Wenn Ihr Code Ablaufverfolgungsdaten ausgibt, sammelt Snowflake die Daten und speichert sie in der von Ihnen erstellten Ereignistabelle.
Ablaufverfolgungsdaten haben strukturelle Eigenschaften, wie in Bereiche (Spans) gruppierte Ereignisdaten und als Schlüssel-Wert-Paare erfasste Daten, die es Ihnen ermöglichen, ein detaillierteres Bild der Aktivität Ihres Codes zu erstellen, als es Protokolldaten normalerweise erlauben.
Snowflake unterstützt APIs jeder unterstützten Handler-Sprache, um Ablaufverfolgungsdaten auszugeben. Für Handler, die Sie in Python schreiben, können Sie das Snowflake-Paket telemetry
verwenden.
So aktualisieren Sie die UDF, um Ablaufverfolgungsdaten auszugeben:
Fügen Sie die folgende Anweisung ein, um festzulegen, welche Ablaufverfolgungsdaten erfasst werden sollen, und führen Sie die Anweisung aus.
ALTER SESSION SET TRACE_LEVEL = ON_EVENT;
Damit wird der Protokolliergrad (Ablaufverfolgungsebene) auf
ON_EVENT
gesetzt. Das bedeutet, dass nur Ablaufverfolgungsdaten erfasst werden sollen, die explizit von Ihrem eigenen Code ausgegeben werden.Fügen Sie die folgende Anweisung ein, um eine UDF zu erstellen, die Ablaufverfolgungsdaten ausgibt, und führen Sie diese Anweisung aus.
CREATE OR REPLACE FUNCTION log_trace_data() RETURNS VARCHAR LANGUAGE PYTHON PACKAGES = ('snowflake-telemetry-python') RUNTIME_VERSION = 3.8 HANDLER = 'run' AS $$ import logging logger = logging.getLogger("tutorial_logger") from snowflake import telemetry def run(): telemetry.set_span_attribute("example.proc.run", "begin") telemetry.add_event("event_with_attributes", {"example.key1": "value1", "example.key2": "value2"}) logger.info("Logging from Python function.") return "SUCCESS" $$;
Wenn Sie diesen Code ausführen, ersetzen Sie die Funktion, die Sie zuvor erstellt haben, durch eine Funktion, die Code für die Ausgabe von Ablaufverfolgungsdaten hinzufügt. Die hervorgehobenen Zeilen bewirken Folgendes:
Hinzufügen von
snowflake-telemetry-python
(enthält dastelemetry
-Paket) zur Ausführungsumgebung der UDF.Importieren des
telemetry
-Pakets, damit Sie dessen Funktionen aufrufen können.Erstellen eines Attributs und Festlegen eines Attributwerts für den Bereich (Span), der von Snowflake bei Ausführung des Codes erstellt wird.
Ein Bereich (Span) repräsentiert die Ausführungseinheit einer Prozedur oder UDF, innerhalb derer Sie mehrere Ereignisse hinzufügen können.
Fügen Sie ein Ereignis (mit seinen eigenen Attributen) hinzu, das als Teil des Bereichs (Span) erfasst werden soll.
Fügen Sie die folgende Anweisung zum Ausführen der soeben erstellten Funktion ein, und führen Sie die Anweisung aus.
SELECT log_trace_data();
Folgende Ausgabe wird erstellt: Außerdem gab die Funktion bei ihrer Ausführung Ablaufverfolgungsdaten aus, die von Snowflake in der Ereignistabelle gesammelt wurden.
-------------------- | LOG_TRACE_DATA() | -------------------- | SUCCESS | --------------------
In diesem Abschnitt haben Sie Ablaufverfolgungsdaten von einer UDF ausgegeben. Im nächsten Abschnitt werden Sie die Ereignistabelle abfragen, um Daten zur Ablaufverfolgung abzurufen.
Ablaufverfolgungsmeldungen abfragen¶
In diesem Abschnitt werden Sie die Ereignistabelle nach Ablaufverfolgungsdaten abfragen, die von der im vorherigen Abschnitt ausgeführten UDF ausgegeben wurden.
Bemerkung
Es kann einige Sekunden dauern, bis die vom Handler-Code ausgegebenen Protokoll- oder Ablaufverfolgungsdaten in der Ereignistabelle erfasst werden. Wenn Sie nicht sofort ein Ergebnis sehen, versuchen Sie es nach ein paar Sekunden erneut.
Mit der von Ihnen geschriebenen Abfrage werden Kontextinformationen zu Ereignissen abgerufen, die von der Funktion ausgegeben wurden. Zu diesem Kontext gehört auch der Name der Funktion, die für die Ausgabe verantwortlich ist.
So fragen Sie die Ereignistabelle nach Ablaufverfolgungsdaten ab:
Fügen Sie die folgende Anweisung zum Abfragen der Ereignistabelle nach Ablaufverfolgungsdaten ein, und führen Sie die Anweisung aus.
SELECT TIMESTAMP AS time, RESOURCE_ATTRIBUTES['snow.executable.name'] AS handler_name, RECORD['name'] AS event_name, RECORD_ATTRIBUTES AS attributes FROM tutorial_log_trace_db.public.tutorial_event_table WHERE RECORD_TYPE = 'SPAN_EVENT' AND HANDLER_NAME LIKE 'LOG_TRACE_DATA%';
Einige Spalten enthalten strukturierte Daten, die als Schlüssel-Wert-Paare ausgedrückt werden. Für diese können Sie Attributwerte innerhalb einer Spalte mit der Klammernotation auswählen, wie im Code gezeigt.
Zeigen Sie die Ausgabe an.
----------------------------------------------------------------------------------------------------------------------------------------------------- | TIME | HANDLER_NAME | EVENT_NAME | ATTRIBUTES | ----------------------------------------------------------------------------------------------------------------------------------------------------- | 2023-05-10 20:49:35.080 | "LOG_TRACE_DATA():VARCHAR(16777216)" | "event_with_attributes" | { "example.key1": "value1", "example.key2": "value2" } | -----------------------------------------------------------------------------------------------------------------------------------------------------
Die Ausgabe veranschaulicht, wie die vordefinierten Spalten der Ereignistabelle jeweils Teile der gesammelten Daten enthalten. Für die Werte von
EXECUTABLE
undSEVERITY
haben Sie die Klammernotation zur Angabe des Attributs verwendet, dessen Wert Sie benötigen.Ausgabespalte
Beschreibung
TIME
Zeitpunkt der Erstellung des Eintrags (aus der Spalte TIMESTAMP).
HANDLER_NAME
Name und Parameter der UDF (aus dem Attribut
snow.executable.name
der Spalte RESOURCE_ATTRIBUTES).EVENT_NAME
Name des Ereignisses, das mit der Funktion
add_event
hinzugefügt wurde (aus dem Attributname
der Spalte RECORD).ATTRIBUTES
Attribute, die dem Ereignis hinzugefügt wurden (aus der Spalte RECORD_ATTRIBUTES).
In diesem Abschnitt haben Sie die Ereignistabelle nach Ablaufverfolgungsdaten abgefragt, die von der von Ihnen geschriebenen UDF ausgegeben wurden. Im letzten Abschnitt finden Sie Links zu Informationen, die sich auf die Aspekte beziehen, die Sie während des Tutorials getan haben.
Mehr erfahren¶
Geschafft! Sehr gut gemacht.
In diesem Tutorial haben Sie einen umfassenden Überblick darüber erhalten, wie Sie Protokoll- und Ablaufverfolgungsdaten über Handler-Code ausgeben und speichern und anschließend die gespeicherten Daten abfragen können. Auf dem Weg dorthin, haben Sie folgende Aufgaben ausgeführt:
Ereignistabelle erstellt. Weitere Informationen zu Ereignistabellen finden Sie hier:
Weitere Informationen zum Einrichten einer Ereignistabelle finden Sie unter Einrichten einer Ereignistabelle.
Referenzinformationen zu den Spalten, aus denen eine Ereignistabelle besteht, finden Sie unter Spalten von Ereignistabellen.
Weitere Informationen zur Verwendung von Ereignistabellen finden Sie unter Verwenden von Ereignistabellen.
Benutzerdefinierte Funktion (UDF) erstellt. Diese Funktion kann Protokoll- und Ablaufverfolgungsdaten ausgeben. Informationen dazu finden Sie hier:
Eine Übersicht zu den Möglichkeiten der Protokollierung in Snowflake finden Sie unter Protokollierung von Meldungen aus Funktionen und Prozeduren. Spezifische Informationen zur Protokollierung mit Python finden Sie unter Protokollierung von Meldungen aus Funktionen und Prozeduren und zum logging-Modul in der Standardbibliothek von Python.
Weitere Informationen zum Einstellen des Protokolliergrads finden Sie unter Einstellen des Protokolliergrads.
Eine Übersicht zu den Features der Ablaufverfolgung finden Sie unter Ablaufverfolgungsereignisse von Funktionen und Prozeduren. Spezifische Informationen zur Ablaufverfolgung mit Python finden Sie unter Ausgeben von Ablaufverfolgungsereignissen in Python.
Weitere Informationen zum Einstellen des Protokolliergrads (Ablaufverfolgungsebene) finden Sie unter Einstellen des Protokolliergrads (Ablaufverfolgungsebene).
Allgemeine Informationen zum Erstellen von UDFs finden Sie unter Übersicht zu benutzerdefinierten Funktionen.
Ereignistabelle abgefragt. Abfragen der Protokoll- und Ablaufverfolgungsdaten. Weitere Informationen zu den Ereignistabellen finden Sie hier:
Eine vollständige Übersicht zu den Optionen für das Abfragen der Protokolldaten finden Sie unter Zugriff auf protokollierte Meldungsdaten.
Eine Übersicht zu den Optionen für das Abfragen von Ablaufverfolgungsdaten finden Sie unter Zugriff auf Ablaufverfolgungsdaten.
Weitere Informationen zu Bereichen (Spans) und Ereignissen sowie Informationen darüber, wie Snowflake Daten für diese speichert, finden Sie unter Darstellung von Ablaufverfolgungsereignissen in Snowflake.