Registro e rastreamento para Streamlit in Snowflake¶

Módulo de registro em log do Python¶

Use o módulo logging interno do Python para emitir mensagens de log do seu app. O exemplo a seguir configura um registrador que grava mensagens no nível INFO e em nível superior na saída padrão:

import logging
import sys

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    stream=sys.stdout,
)

LOGGER = logging.getLogger("my_app")

Na ordem do menos para o mais grave, o Python tem os seguintes níveis de registro em log:

• DEBUG

• INFO

• WARNING

• ERROR

Definir o nível como INFO captura mensagens INFO, WARNING e ERROR, mas não mensagens DEBUG.

Depois de configurar o registrador, você poderá usá-lo para registrar mensagens envolvendo todo o código do app. É comum definir um registrador em um módulo separado e importá-lo para o código do seu app:

source_directory/
├── my_logger.py
├── pyproject.toml
└── streamlit_app.py

import streamlit as st
from my_logger import LOGGER

LOGGER.info("Home page loaded")
st.title("My App")

if st.button("Run analysis"):
    LOGGER.info("Analysis button clicked")
    try:
        result = run_analysis()
        LOGGER.info("Analysis completed successfully")
    except Exception as e:
        LOGGER.error("Analysis failed: %s", e)
        st.error("Analysis failed: %s", e)

Logs ativos no Snowsight¶

Quando você edita um app de tempo de execução de contêiner no Snowsight, um painel de logs aparece abaixo do editor. Esse painel transmite as mensagens de log em tempo real conforme seu app as emite. Um pequeno histórico dos logs mais recentes é exibido quando você se conecta pela primeira vez.

Cada entrada de log mostra as seguintes informações:

Ações de log ativo disponíveis¶

No canto superior direito do painel de logs, é possível pesquisar e filtrar os logs para ajudar a encontrar as informações necessárias. Isso inclui pesquisa de texto, filtragem por fonte e filtragem por nível de gravidade. No menu de três pontos, você pode baixar os logs atuais, navegar até os logs históricos ou limpar o painel de registro ativo. Quando você limpa o painel, os logs atuais são excluídos da exibição atual, mas não da tabela de eventos. Um recarregamento imediato da página restaura os logs mais recentes.

Explicação das fontes de log¶

Os logs de apps de tempo de execução de contêiner têm uma de duas fontes:

• MANAGER: o processo do sistema dentro do contêiner que prepara e executa seu app. Os logs do gerenciador incluem mensagens sobre como baixar os arquivos do seu apo da área de preparação, instalar as dependências do Python e iniciar o processo do servidor Streamlit. Se você atualizar os arquivos de dependência do seu app enquanto ele estiver em execução, o processo do gerenciador reinstalará as dependências e produzirá logs adicionais do gerenciador.

• APP: logs do processo do servidor Streamlit em execução. Isso inclui mensagens de seus registradores Python configurados pelo usuário, do registrador interno do Streamlit e de qualquer outra saída que seu app grava na saída padrão ou no erro padrão.

O limite entre as fontes é o comando streamlit run. Tudo que o contêiner faz antes de iniciar o processo do Streamlit produz logs do MANAGER. Após o início do processo do Streamlit, a saída desse processo produzirá logs do APP.

Visualizar logs históricos no Snowsight¶

As etapas a seguir se aplicam somente a apps de tempo de execução de contêiner. Os apps de tempo de execução de warehouse não têm um painel de logs.

1. Faça login no Snowsight.

2. No menu de navegação, clique em Projects » Streamlit e selecione seu app.

3. No canto superior direito da página, selecione Edit.

4. No canto superior direito do painel de logs, selecione o menu de três pontos (Other actions) » Historical logs.

Esse procedimento abre a página de monitoramento do Snowpark Container Services para o serviço executado por seu app. A tabela de logs mostra as seguintes colunas:

Para obter mais informações sobre a página de monitoramento, consulte Snowpark Container Services: Serviços de monitoramento.

Consultar logs com SQL¶

Você pode consultar diretamente a tabela de eventos para analisar os logs do seu app de tempo de execução de contêiner. A consulta a seguir recupera os logs de um app Streamlit específico:

SELECT
    TIMESTAMP,
    RECORD['severity_text']::VARCHAR AS level,
    VALUE::VARCHAR AS message,
    RESOURCE_ATTRIBUTES['snow.database.name']::VARCHAR AS database_name,
    RESOURCE_ATTRIBUTES['snow.schema.name']::VARCHAR AS schema_name,
    RESOURCE_ATTRIBUTES['snow.executable.name']::VARCHAR AS app_name,
    RECORD_ATTRIBUTES['log.iostream']::VARCHAR AS stream
FROM <event_table>
WHERE RESOURCE_ATTRIBUTES['snow.database.name'] = '<database_name>'
  AND RESOURCE_ATTRIBUTES['snow.schema.name'] = '<schema_name>'
  AND RESOURCE_ATTRIBUTES['snow.executable.name'] = '<app_name>'
  AND RECORD_TYPE = 'LOG'
  AND TIMESTAMP > DATEADD(hour, -1, CURRENT_TIMESTAMP())
ORDER BY TIMESTAMP DESC
LIMIT 100;

Substitua <event_table> pelo nome da tabela de eventos retornado pelo comando SHOW PARAMETERS e substitua <database_name>, <schema_name> e <app_name> pelos valores do seu app Streamlit.

Para obter mais informações sobre as colunas da tabela de eventos, consulte Colunas da tabela de eventos.

Exemplo: Registro de um app de tempo de execução de warehouse¶

import logging
import streamlit as st

logger = logging.getLogger("simple_logger")

# Write directly to the app
st.title("Simple Logging Example")

# Get the current credentials
session = st.connection('snowflake').session()

def get_log_messages_query() -> str:
    return """
            SELECT
                TIMESTAMP,
                RECORD:"severity_text"::VARCHAR AS SEVERITY,
                RESOURCE_ATTRIBUTES:"db.user"::VARCHAR AS USER,
                VALUE::VARCHAR AS VALUE
            FROM
                SAMPLE_EVENTS
            WHERE
                SCOPE:"name" = 'simple_logger'
            ORDER BY
                TIMESTAMP DESC;
            """

button = st.button("Log a message")

if button:
    try:
        logger.info("Logging an info message through Streamlit App.")
        st.success('Logged a message')
    except Exception as e:
        logger.error("Logging an error message through Streamlit App: %s",e)
        st.error('Logged an error')

sql = get_log_messages_query()

df = session.sql(sql).to_pandas()

with st.expander("**Show All Messages**"):
     st.dataframe(df, use_container_width=True)