Centro de suporte da Workiva

Ao impor limites de recursos automaticamente e fornecer registros detalhados (como mostrado nas capturas de tela abaixo), o Workiva Scripting garante a confiabilidade e a transparência da plataforma para os desenvolvedores que criam e otimizam scripts de automação.

Quando você termina uma execução com sucesso

Quando um script é concluído normalmente sem exceder os limites, o registro inclui um resumo do uso de recursos mostrando a média e o pico de uso da memória, da CPU, do disco e do tempo de execução. Com essas informações, você terá visibilidade das características de desempenho das execuções concluídas com sucesso.

Nota: Se um script for executado muito rapidamente (por exemplo, menos de 1 segundo), a amostragem de recursos poderá não ocorrer. Nesses casos, nenhum dado de uso de recurso será relatado no log.

O script é executado muito rápido para que você possa fazer uma amostra

Se um script terminar muito rapidamente, o monitor não poderá capturar dados de uso.

O script saiu normalmente

Se um script for concluído sem exceder nenhum limite, as estatísticas de uso de recursos serão totalmente exibidas no registro.

Encerramento quando os limites forem excedidos

Se um script executado exceder seus limites configurados (por exemplo, memória, uso de disco ou tempo alocado), o Scripting irá:

1. Tentativa de parar o script com segurança - Quando os limites são excedidos, o Scripting primeiro envia um sinal de encerramento (SIGTERM) para permitir que o script seja limpo e saia em 15 segundos.
2. Se o script não sair dentro de 15 segundos, o script enviará um sinal SIGKILL, que interromperá imediatamente o processo sem permitir nenhuma limpeza. Isso é um encerramento forçado, e a execução será concluída com um status de falha (exibido em vermelho no log). Esse status indica um erro do sistema de script.
3. Registre o motivo da interrupção - o log mostrará qual limite foi atingido e resumirá o uso de recursos do script.

As próximas seções fornecem exemplos do que acontece quando um script excede os limites sem código para lidar com esses sinais. Para saber como Alterar os scripts para que eles respondam com elegância a esses sinais, consulte Manipulação de sinais do sistema em scripts.

Limite de memória excedido

Quando um script excede o limite de memória configurado, o registro inclui o motivo do encerramento e detalhes sobre o limite excedido.

Limite de uso do disco excedido

Quando um script excede o limite de uso do disco configurado, o registro inclui o motivo do encerramento e detalhes sobre o uso do disco no momento em que o limite foi atingido.

Tempo alocado excedido

Quando um script excede o tempo alocado configurado, o log inclui o motivo do término e o tempo total de execução registrado.

Encerramento quando o usuário cancela uma execução

Se um usuário cancelar manualmente uma execução, o Scripting enviará primeiro um sinal de interrupção (SIGINT) para que o script saiba que deve parar. O script tem 15 segundos para fazer a limpeza, salvar como está progredindo ou reverter antes do desligamento. Após esse período de tolerância de 15 segundos, ocorre a mesma sequência descrita acima: um sinal de encerramento (SIGTERM) é enviado para permitir que mais 15 segundos o script conclua a limpeza, seguido de um sinal de interrupção final (SIGKILL) se o script ainda não tiver saído.

A imagem abaixo mostra como os logs do script aparecem quando o script não inclui código para lidar com o sinal de interrupção.

Para saber como Alterar os scripts para que respondam de forma adequada a esses sinais, consulte Manipulação de sinais do sistema em scripts.

Encerramentos não planejados

Em casos raros, como quando um script consome memória mais rapidamente do que o sistema Scripting pode monitorar o consumo, o sistema pode encerrar um script antes de detectar que um limite foi excedido. Quando isso acontece, o Scripting registra um relatório de uso incompleto, mostrando apenas os pontos de dados coletados antes do encerramento.

Manipulação de sinais do sistema em scripts

O tratamento de sinais permite que você feche o script de forma limpa quando ele for cancelado ou interrompido pelo sistema. Ao capturar e responder aos sinais do sistema, seu script pode liberar recursos, salvar o trabalho e sair de forma graciosa (por exemplo, quando o status é relatado como "concluído") em vez de ser encerrado à força.

Quando um script é interrompido porque um usuário o cancela ou porque excede os limites da plataforma, o Scripting fornece sinais de interrupção, encerramento e eliminação. Consulte as seções anteriores para saber mais sobre como os sinais de interrupção, encerramento e eliminação são acionados.

Sinais de script e como lidar com eles

Esta seção fornece blocos de código e um exemplo completo que você pode usar para lidar com esses sinais.

Você pode manter seus manipuladores de sinal pequenos e lidar com a limpeza em um único lugar usando um bloco try/finally que sempre é executado no desligamento. Isso mantém os scripts previsíveis e fáceis de manter.

A estrutura geral para lidar com sinais em seu script é a mesma, independentemente do sinal recebido:

• Parte superior do arquivo: importar módulos e definir o manipulador
• Inicialização antecipada: registre o manipulador antes de fazer qualquer trabalho
• Em torno de seu trabalho: envolva o código principal em um bloco try/finally para que a limpeza seja sempre executada

O usuário cancela a execução (SIGINT)

Isso ocorre quando um usuário clica em Cancel para cancelar a execução do script.

# --- Início do arquivo --- import signal, sys # Manipulador minúsculo: solicita saída imediata e graciosa def _graceful_exit(signum, frame): print("SIGINT received: cancellation requested. Cleaning up...") raise SystemExit(0) # --- Inicialização antecipada --- signal.signal(signal.SIGINT, _graceful_exit)

Em torno de seu trabalho (mais adiante no arquivo):

tente: # o trabalho que você está executando há muito tempo está aqui ... finally: # local central para fechar arquivos, liberar logs etc. print("Final cleanup before exit")

A imagem abaixo mostra como os logs do script aparecem quando o sinal de interrupção (SIGINT) é tratado.

Manuseio direto de KeyboardInterrupt

A Workiva Scripting também gera KeyboardInterrupt quando o SIGINT é entregue ao tópico/discussão principal. Você pode capturar essa exceção em seu bloco try e chamar o mesmo caminho de limpeza definido por _graceful_exit().

try: # seu trabalho de longa duração está aqui ... except KeyboardInterrupt: print("KeyboardInterrupt received: cleaning up before exit...") _graceful_exit(None, None) finally: # local central para fechar arquivos, arquivar registros etc. print("Limpeza final antes de sair")

A imagem abaixo mostra como os logs do script são exibidos quando o sinal de interrupção é tratado por meio da interrupção do teclado.

Sinal de terminação do script para que você pare após um período de carência (SIGTERM)

O script pede que você pare (por exemplo, depois que os limites forem excedidos). Seu script tem um curto período de carência para sair.

# --- Início do arquivo --- def _graceful_term(signum, frame): print("SIGTERM received: platform requested termination. Finalizando...") raise SystemExit(0) # --- Inicialização antecipada --- signal.signal(signal.SIGTERM, _graceful_term)

A imagem abaixo mostra como os logs do script aparecem quando o sinal de terminação (SIGTERM) é tratado.

Sinal de interrupção do script para que você pare imediatamente (SIGKILL)

Se o seu script não sair durante o período de carência, o Scripting enviará SIGKILL. Você não pode capturar o SIGKILL. Saia imediatamente do SIGINT/SIGTERM para que seu bloco finalizado em possa ser executado antes que ocorra uma eliminação.

As capturas de tela das seções anteriores mostram a aparência dos logs como resultado do sinal de eliminação.

Exemplo completo (pronto para copiar e colar)

Este modelo registra manipuladores mínimos e centraliza a limpeza em finalizado em. Cole no Workiva Scripting e substitua a área marcada por sua lógica.

Onde você deve adicionar seu código: Substitua a amostra de loop em # ===== SEU CÓDIGO COMEÇA AQUI ===== pelas tarefas que você realmente tem. Evite chamadas muito longas e ininterruptas para que o script possa acessar o bloco finalizado antes que a plataforma passe para SIGKILL.

"""Workiva Scripting template: manipuladores mínimos + limpeza em finally - Manipuladores minúsculos levantam SystemExit(0) em SIGINT/SIGTERM - Um único bloco finally é executado para limpeza, independentemente de como o script é finalizado - Mantém o código pequeno e previsível """ import signal import time # --- Manipuladores de sinal (manter minúsculo) --- def _graceful_exit(signum, frame): print("SIGINT recebido: cancelamento solicitante. Limpando...") raise SystemExit(0) def _graceful_term(signum, frame): print("SIGTERM recebido: a plataforma solicitou o encerramento. Finalizando...") raise SystemExit(0) # --- Registre os manipuladores ANTES de fazer qualquer trabalho pesado --- signal.signal(signal.SIGINT, _graceful_exit) signal.signal(signal.SIGTERM, _graceful_term) # --- O trabalho principal do seu script --- def main(): print("Iniciando o trabalho...") # ===== SEU CÓDIGO COMEÇA AQUI ===== # Exemplo de loop de longa duração. Substitua com sua lógica real. for i in range(1, 1_000_000): # Simule uma unidade de trabalho (substitua pela lógica real) print(f "Working on item {i}...") time.sleep(1) # ===== SEU CÓDIGO ENCERRA AQUI ===== if __name__ == "__main__": try: main() finally: # Limpeza centralizada que sempre é executada (incluindo em SIGINT/SIGTERM) print("Limpeza final antes de sair")