> ## 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.

# Atributos de instrumentação do OpenTelemetry

O AppSignal suporta várias integrações de linguagem do OpenTelemetry. No entanto, o modelo de dados nem sempre se alinha perfeitamente, o que pode afetar como os dados do OpenTelemetry são exibidos na interface do AppSignal. Usando os atributos listados nesta página, você pode personalizar a aparência dos dados de trace e span.

<Warning>
  🔐 Não envie <strong>Informações Pessoais Identificáveis (PII)</strong> para a AppSignal. Filtre PII (por exemplo, nomes, e-mails) e use um ID, hash ou identificador pseudonimizado no lugar. <br /> <br /> Para <strong>entidades cobertas pela HIPAA</strong>, mais informações sobre como assinar um Business Associate Agreement (BAA) estão disponíveis em nossa <a href="/support/business-add-ons">documentação de Business Add-Ons</a>.
</Warning>

## Acessando um span

<Tabs>
  <Tab title="Python">
    Ao personalizar o trace ou span, primeiro importe o módulo `trace` do OpenTelemetry no arquivo em que você quer personalizar os dados de trace reportados.

    <CodeGroup>
      ```python Python theme={null}
      from opentelemetry import trace
      ```
    </CodeGroup>

    Usando esse módulo `trace`, crie um novo span:

    <CodeGroup>
      ```python Python theme={null}
      tracer = trace.get_tracer(__name__)
      with tracer.start_as_current_span("Span name") as span:
          # Define valores de atributo
          span.set_attribute("attribute name", "attribute value")
      ```
    </CodeGroup>

    Ou obtenha o ativo atual:

    <CodeGroup>
      ```python Python theme={null}
      span = trace.get_current_span()
      # Define valores de atributo
      span.set_attribute("attribute name", "attribute value")
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Go (golang)">
    Ao personalizar o trace ou span, primeiro importe o módulo `trace` do OpenTelemetry no arquivo em que você quer personalizar os dados de trace reportados.

    <CodeGroup>
      ```go Go theme={null}
      import (
      	"go.opentelemetry.io/otel"
      	"go.opentelemetry.io/otel/attribute"
      	"go.opentelemetry.io/otel/trace"
      )
      ```
    </CodeGroup>

    Usando esse módulo `trace`, crie um novo span:

    <CodeGroup>
      ```go Go theme={null}
      var tracer = otel.Tracer("my-tracer-name")

      func httpHandler(w http.ResponseWriter, r *http.Request) {
      	ctx, span := tracer.Start(r.Context(), "hello-span")
      	defer span.End()

      	// Define atributos
      }
      ```
    </CodeGroup>

    *Nota: Nestes exemplos estamos confiando no contexto da requisição HTTP, fornecido por `r.Context()`.*
    *Receber o contexto pode ser diferente na sua aplicação.*

    Ou obtenha o ativo atual:

    <CodeGroup>
      ```go Go theme={null}
      func httpHandler(w http.ResponseWriter, r *http.Request) {
      	ctx := r.Context()
          span := trace.SpanFromContext(ctx)

      	// Define atributos
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Atributos do AppSignal

### Namespace

<Tip>
  Este atributo se aplica a todo o trace. Ele pode ser definido em um span filho e não precisa ser definido no span pai mais externo. Este atributo só pode ser definido uma vez por trace. Se for definido várias vezes, apenas o atributo de um span no trace será aplicado.
</Tip>

* Nome do atributo: `appsignal.namespace`
* Tipo do valor: `String`

[Agrupe traces por namespace](/application/namespaces) para melhor organização na interface do AppSignal.

Os namespaces são agrupados por nome de serviço do OpenTelemetry com o formato `<Service name>/<Namespace>`, por exemplo, "Web server/admin" ou "Background worker/billing". Este atributo permite configurar apenas a parte do namespace. O namespace padrão para todos os traces é `<Service name>/default`.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.namespace", "admin")
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.namespace", "admin"))
  ```
</CodeGroup>

### Nome da ação raiz

<Tip>
  Este atributo se aplica a todo o trace. Ele pode ser definido em um span filho e não precisa ser definido no span pai mais externo. Este atributo só pode ser definido uma vez por trace. Se for definido várias vezes, apenas o atributo de um span no trace será aplicado.
</Tip>

* Nome do atributo: `appsignal.action_name`
* Tipo do valor: `String`

Defina o nome da ação do trace que será usado para criar incidentes e agrupar o tracing no AppSignal.com. Isso sobrescreverá qualquer mapeamento automatizado feito pelo suporte do AppSignal para uma instrumentação específica. É útil para traces que não são criados por bibliotecas suportadas. Se o seu trace está agrupado com outros traces sem nome ou mal agrupados, pode ser que esteja faltando este atributo.

Pretendemos melhorar nosso agrupamento automático ao longo do tempo, então [avise-nos](mailto:support@appsignal.com?subject=OpenTelemetry%20feedback) quando achar que este atributo é necessário.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.action_name", "ControllerName#action")
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.action_name", "ControllerName#action"))
  ```
</CodeGroup>

### Tags

* Nome do atributo: `appsignal.tag.<tag_name>`
* Tipo do valor: `String`

[Tagueie traces](/application/tagging) para destacá-los nas páginas de detalhes do trace e filtrar traces na interface do AppSignal. Várias tags podem ser definidas em spans de um trace. Tags podem ser adicionadas a qualquer span de um trace em qualquer nível do trace.

Você pode usar [templates de link](https://docs.appsignal.com/application/link-templates.html) para vincular tags a uma URL específica, como um perfil de usuário ou página de admin.

A chave do atributo de tag é composta por duas partes: o prefixo `appsignal.tag` e a chave da tag. Para a tag `user_id`, isso se torna `appsignal.tag.user_id` como chave de atributo.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.tag.<tag_name>", "string") # Formato de exemplo
  span.set_attribute("appsignal.tag.user_id", user.id)
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.tag.<tag_name>", "string")) // Formato de exemplo
  span.SetAttributes(attribute.String("appsignal.tag.user_id", user.id))
  ```
</CodeGroup>

### Parâmetros de função

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `appsignal.function.parameters`
* Tipo do valor: Objeto serializado em JSON

Reporte os parâmetros para uma chamada de função usando este atributo.
Use isso para definir parâmetros passados a um job em background, uma tarefa ou chamada de função que você gostaria de rastrear.

Os valores definidos neste atributo de span podem ser filtrados usando a [opção de configuração `appsignal.config.filter_function_parameters`](/opentelemetry/configuration/options#filter-function-parameters).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.function.parameters", json.dumps({
      "param1": "value1",
      "param2": "value2"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"
  )

  params := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.function.parameters", string(json)))
  ```
</CodeGroup>

### Cabeçalhos de resposta

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `http.response.header.<key>`
* Tipo do valor: Array de Strings

Reporte os cabeçalhos da resposta usando um atributo de span do OpenTelemetry.
Este atributo de span também está documentado na [especificação de span HTTP do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("http.response.header.content-type", ["application/json"])
  span.set_attribute("http.response.header.custom-header", ["abc", "def"])
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.StringSlice("http.response.header.content-type", []string{"application/json"}))
  span.SetAttributes(attribute.StringSlice("http.response.header.custom-header", []string{"abc", "def"}))
  ```
</CodeGroup>

### Cabeçalhos de requisição

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `http.request.header.<key>`
* Tipo do valor: Array de Strings

Reporte os cabeçalhos da requisição usando um atributo de span do OpenTelemetry.
Este atributo de span também está documentado na [especificação de span HTTP do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("http.request.header.content-type", ["application/json"])
  span.set_attribute("http.request.header.custom-header", ["abc", "def"])
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.StringSlice("http.request.header.content-type", []string{"application/json"}))
  span.SetAttributes(attribute.StringSlice("http.request.header.custom-header"), []string{"abc", "def"})
  ```
</CodeGroup>

### Query parameters de requisição

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `appsignal.request.query_parameters`
* Tipo do valor: Objeto serializado em JSON

Reporte os query parameters de uma requisição HTTP de entrada usando este atributo.

Os valores definidos neste atributo de span podem ser filtrados usando a [opção de configuração `appsignal.config.filter_request_query_parameters`](/opentelemetry/configuration/options#filter-request-query-parameters).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.query_parameters", json.dumps({
      "category": "shoes",
      "filter": "color:blue"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  params := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.query_parameters", string(json)))
  ```
</CodeGroup>

### Payload da requisição

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `appsignal.request.payload`
* Tipo do valor: Objeto serializado em JSON

Reporte o payload de uma requisição HTTP de entrada usando este atributo.

Os valores definidos neste atributo de span podem ser filtrados usando a [opção de configuração `appsignal.config.filter_request_payload`](/opentelemetry/configuration/options#filter-request-payload).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.payload", json.dumps({
      "title": "My new blog post"
      "body": "Lorem ipsum"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  payload := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(payload)
  span.SetAttributes(attribute.String("appsignal.request.payload", string(json)))
  ```
</CodeGroup>

### Dados de sessão da requisição

<Tip>
  O valor deste atributo precisa ser serializado como uma string JSON. Ele não aceita um Hash ou objeto da linguagem de integração diretamente e será silenciosamente ignorado.
</Tip>

* Nome do atributo: `appsignal.request.session_data`
* Tipo do valor: Objeto serializado em JSON

Reporte os dados de sessão de uma requisição HTTP de entrada usando este atributo.

Os valores definidos neste atributo de span podem ser filtrados usando a [opção de configuração `appsignal.config.filter_request_session_data`](/opentelemetry/configuration/options#filter-request-session-data).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.session_data", json.dumps({
      "user_id": 123
      "theme": "dark"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  session_data := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(session_data)
  span.SetAttributes(attribute.String("appsignal.request.session_data", string(json)))
  ```
</CodeGroup>