> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# AppSignal Wrap para monitoramento de processos

export const Compatibility = ({versions = [], label = "Available in"}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const defaultPillStyle = {
    borderColor: "#d4d4d8",
    background: "#f4f4f5",
    color: "#3f3f46"
  };
  const pillStyles = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#d8b4fe",
      color: "#6b21a8"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#5eead4",
      color: "#115e59"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#86efac",
      color: "#166534"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#93c5fd",
      color: "#1e40af"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fca5a5",
      color: "#991b1b"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fdba74",
      color: "#9a3412"
    }
  };
  const getPillStyle = name => ({
    ...defaultPillStyle,
    ...pillStyles[name] || ({})
  });
  return <div className="not-prose my-4 rounded-lg border border-zinc-200 bg-zinc-50 px-4 py-3 text-sm dark:border-white/10 dark:bg-white/5">
      <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
        <span className="font-semibold text-zinc-700 dark:text-zinc-200">
          {label}:
        </span>
        {versions.map((v, i) => <span key={`${v.name}-${v.version}-${i}`} className="inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium" style={getPillStyle(v.name)}>
            <span>{v.name}</span>
            <span className="opacity-70">
              {v.version}
              {v.exact ? "" : "+"}
            </span>
          </span>)}
      </div>
    </div>;
};

O AppSignal fornece o `appsignal-wrap`, uma ferramenta para monitorar qualquer processo em execução no seu servidor, como seus cron jobs, seu servidor de banco de dados ou quaisquer outros processos relacionados à sua aplicação.

A ferramenta `appsignal-wrap` integra-se perfeitamente aos monitores de processos cron e heartbeat do AppSignal, logging e relatórios de erros. Pode ser usada para monitorar qualquer processo em execução nos seus servidores, independentemente da linguagem ou framework em que esteja escrito.

### O AppSignal Wrap ajuda a responder perguntas como:

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Meu processo de banco de dados está em execução?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Meu cron job está rodando no horário?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>O que deu errado com meu script de backup?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Meu servidor de aplicação falhou ao iniciar?</span>
</div>

### Principais recursos do appsignal-wrap

Após instalar o `appsignal-wrap`, você pode usar a ferramenta para iniciar os processos que deseja monitorar. A ferramenta `appsignal-wrap` irá então:

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#fce7f3', borderRadius: '8px' }}>
    <Icon icon="line-columns" color="#ec4899" />
  </span>

  <span>Reportar a saída padrão e o erro padrão do processo, como logs que você pode filtrar e consultar no [AppSignal Logging](/logging).</span>
</div>

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dbeafe', borderRadius: '8px' }}>
    <Icon icon="square-check" iconType="solid" color="#3b82f6" />
  </span>

  <span>Enviar [monitores de processos cron](/check-ins) para reportar que o processo iniciou e terminou com sucesso, ou [monitores de processos heartbeat](/check-ins) para acompanhar seu tempo de atividade.</span>
</div>

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#fee2e2', borderRadius: '8px' }}>
    <Icon icon="siren-on" iconType="solid" color="#ef4444" />
  </span>

  <span>Reportar status de saída de falha como erros para o AppSignal.</span>
</div>

## Instalação

A maneira mais fácil de instalar o `appsignal-wrap` é executar o seguinte comando:

<CodeGroup>
  ```bash Bash theme={null}
  curl -sSL https://github.com/appsignal/appsignal-wrap/releases/latest/download/install.sh | sudo sh
  ```
</CodeGroup>

O comando fará automaticamente o download da última versão do `appsignal-wrap` para seu SO (sistema operacional) e arquitetura, e o instalará no `$PATH` do seu servidor.

Tanto Linux quanto macOS são suportados, nas arquiteturas x86 64-bit (Intel) e ARM 64-bit (Apple Silicon). O Alpine Linux também é suportado através dos nossos builds com `musl` habilitado para ambas as arquiteturas.

Alternativamente, você pode baixar a última versão na [página de releases do GitHub](https://github.com/appsignal/appsignal-wrap/releases/latest/) para seu sistema operacional e arquitetura, e instalá-la manualmente no `$PATH` do seu servidor.

## Uso

Para monitorar um processo com o `appsignal-wrap`, você passa o comando que deseja monitorar como o último argumento para o `appsignal-wrap`. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  export APPSIGNAL_APP_PUSH_API_KEY=[APP_LEVEL_API_KEY]
  appsignal-wrap [NAME] -- [COMMAND]
  ```
</CodeGroup>

No exemplo acima, `[NAME]` é o nome que você quer usar para identificar o processo no AppSignal, e `[COMMAND]` é o comando que você quer monitorar. Tanto o nome quanto o comando são obrigatórios. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup-script -- bash /var/app/backup.sh
  ```
</CodeGroup>

Você precisará de uma chave API do AppSignal no nível do app, que pode encontrar nas configurações ["Push & Deploy"](https://appsignal.com/redirect-to/app?to=api_keys\&key_tab=app) do seu app AppSignal.

Você pode fornecê-la para o `appsignal-wrap` como argumento da opção de linha de comando `--api-key`, ou como variável de ambiente `APPSIGNAL_APP_PUSH_API_KEY`.

Por padrão, o `appsignal-wrap` reportará a saída padrão e o erro padrão do processo como logs para o AppSignal, e reportará quaisquer status de saída de falha como erros para o AppSignal.

<span id="check-ins" />

## Monitoramento de Processos

<Tip>
  [Leia nossa documentação de Monitoramento de Processos](/check-ins) para mais informações sobre como
  o Monitoramento de Processos do AppSignal funciona.
</Tip>

Por padrão, o `appsignal-wrap` não enviará nenhum evento de monitor de processo. Você pode usar as opções de linha de comando `--cron`
ou `--heartbeat` para habilitar monitores de processo do tipo cron ou heartbeat, respectivamente.

A ferramenta `appsignal-wrap` usará o nome fornecido como primeiro argumento como o identificador do monitor de processo. Por exemplo, para reportar eventos de monitor de processo do tipo cron com `backup-script` como identificador do monitor de processo:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup-script --cron -- bash /var/app/backup.sh
  ```
</CodeGroup>

### Monitores de processo do tipo cron

Ao usar `--cron` para enviar monitores de processo do tipo cron, o `appsignal-wrap` enviará um evento de início de monitor de processo cron quando o processo iniciar, e um evento de finalização de monitor de processo cron se o processo finalizar com sucesso.

Se o processo encerrar com status de saída de falha, o `appsignal-wrap` não enviará um evento de finalização de monitor de processo cron.

### Monitores de processo do tipo heartbeat

Ao usar `--heartbeat` para enviar monitores de processo do tipo heartbeat, o `appsignal-wrap` enviará eventos de monitor de processo heartbeat continuamente durante o tempo de vida do processo.

### Identificador personalizado

Para enviar eventos de monitor de processo ao AppSignal com um identificador diferente do nome fornecido como primeiro argumento, você pode passar um identificador diferente como argumento para as opções de linha de comando `--cron` ou `--heartbeat`. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup --cron daily-backup -- bash /var/app/backup.sh
  ```
</CodeGroup>

No exemplo acima, o `appsignal-wrap` enviará eventos de monitor de processo cron com `daily-backup` como identificador do monitor de processo, mas ainda usará `backup` como o nome para identificar o processo ao reportar logs e erros.

## Logging

Por padrão, o `appsignal-wrap` enviará tanto a saída padrão quanto a saída de erro padrão do processo monitorado como logs para o AppSignal. Os logs aparecerão sob a fonte "application", e o nome fornecido como primeiro argumento será usado como o grupo de logs.

### Desabilitar logging

Para desabilitar o envio da saída padrão ou da saída de erro padrão como logs, você pode usar as opções de linha de comando `--no-stdout` ou `--no-stderr`, respectivamente.

Para desabilitar o envio de logs completamente, você pode usar a opção de linha de comando `--no-log`.

### Grupo de logs personalizado

Para enviar logs como um grupo de logs diferente, você pode passá-lo como argumento para a opção de linha de comando `--log`. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap mysql --log db -- mysqld
  ```
</CodeGroup>

No exemplo acima, o `appsignal-wrap` usará `db` como o grupo de logs ao enviar logs para o AppSignal, mas ainda usará `mysql` como o nome para identificar o processo ao reportar monitores de processo e erros.

### Fonte de logs personalizada

Para enviar logs para uma fonte de logs diferente, você pode passar a chave de API da fonte de logs, que você obtém ao [criar uma fonte de logs](https://docs.appsignal.com/logging/configuration.html#creating-a-log-source), como argumento para a opção de linha de comando `--log-source`, ou como a variável de ambiente `APPSIGNAL_LOG_SOURCE_API_KEY`. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  export APPSIGNAL_LOG_SOURCE_API_KEY=[LOG_SOURCE_API_KEY]
  appsignal-wrap mysql -- mysqld
  ```
</CodeGroup>

## Relatório de erros

Por padrão, o `appsignal-wrap` reportará qualquer status de saída de falha do processo que monitora como erros para o AppSignal. Os erros serão agrupados pelo nome fornecido como primeiro argumento.

### Desabilitar relatório de erros

Para desabilitar completamente o relatório de erros, você pode usar a opção de linha de comando `--no-error`.

### Saída em mensagens de erro

Ao reportar erros para o AppSignal, o `appsignal-wrap` incluirá as últimas linhas da saída padrão e do erro padrão do processo como a mensagem de erro.

Usar as opções de linha de comando `--no-stdout` ou `--no-stderr` impedirá que a saída padrão ou o erro padrão sejam incluídos na mensagem de erro.

Usar ambas as opções impedirá que quaisquer logs sejam incluídos na mensagem de erro.

### Agrupamento de erros personalizado

Para agrupar erros de forma diferente, você pode passar um nome diferente como argumento para a opção de linha de comando `--error`. Por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup --error user-backup -- bash /var/app/backup.sh --only-users
  ```
</CodeGroup>

No exemplo acima, o `appsignal-wrap` reportará erros com `user-backup` como grupo de erros, mas ainda usará `backup` como o nome para identificar o processo ao reportar logs e monitores de processo.

### Revisão da aplicação

<Compatibility versions={[{ name: "AppSignal Wrap", version: "0.3.1" }]} />

Se uma revisão for fornecida usando a flag `--revision` ou a variável de ambiente `APPSIGNAL_REVISION`, os erros serão agrupados com o deploy daquela revisão.

## Comportamento do processo

A ferramenta `appsignal-wrap` busca ser *transparente* -- ou seja, executar algum comando usando o `appsignal-wrap` deve ter o mesmo comportamento que executar esse mesmo comando sozinho.

<Note>
  Depois que o processo monitorado terminar, o `appsignal-wrap` aguardará um curto período de tempo *(geralmente um segundo ou menos)* antes de sair, a fim de garantir que todos os logs e monitores de processo sejam enviados ao AppSignal.

  Se você invocar o `appsignal-wrap` em um loop, o atraso causado por essa espera pode fazer com que o loop rode mais lento do que o esperado.
</Note>

### Variáveis de ambiente

O processo herda automaticamente as variáveis de ambiente do processo pai `appsignal-wrap`.

### Status de saída

Se o processo que ele monitora sai com um código de saída, o `appsignal-wrap` sairá com o mesmo código de saída de falha.

Se o processo que ele monitora é encerrado por um sinal, o `appsignal-wrap` sairá com um código de saída de falha de `128 + signal`, onde `signal` é o número que representa o sinal que causou o término do processo. O sinal que esse número representa é específico do sistema operacional.

### Entrada e saída

O processo herda automaticamente seu descritor de entrada padrão do processo pai `appsignal-wrap`.

Além de reportá-las ao AppSignal, a saída padrão e o erro padrão do processo são canalizados para a saída padrão e o erro padrão do processo pai `appsignal-wrap`.

Ao usar `--no-stdout` ou `--no-stderr`, o processo herda automaticamente o descritor de saída padrão ou erro padrão, respectivamente, do processo pai `appsignal-wrap`.

Isso significa que você pode usar o `appsignal-wrap` em um pipeline, ou redirecionar sua saída para um arquivo, por exemplo:

<CodeGroup>
  ```sh Shell theme={null}
  # Without monitoring
  grep "active" customers.csv \
      | python /var/app/import.py \
      > /var/log/import.log

  # With monitoring
  grep "active" customers.csv \
      | appsignal-wrap import-customers -- python /var/app/import.py \
      > /var/log/import.log
  ```
</CodeGroup>

### Sinais

Quando o processo `appsignal-wrap` recebe um sinal que pode ser tratado, ele o encaminhará para o processo que monitora.

Por exemplo, enviar um sinal `SIGTERM` para o processo pai `appsignal-wrap` fará com que o processo que ele monitora receba um sinal `SIGTERM`.

Quando o processo pai `appsignal-wrap` recebe um sinal que não pode ser tratado, como `SIGKILL` e `SIGSTOP`, ou se ele falha inesperadamente, um sinal `SIGTERM` será enviado para o processo que ele monitora.