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

# Opções de configuração do OpenTelemetry

O AppSignal pode ser configurado por meio de atributos de recurso do OpenTelemetry. Nesta página vamos descrever como configurar atributos de recurso e quais atributos podem ser definidos.

## Configurando atributos de recurso do OpenTelemetry

Você pode configurar o OpenTelemetry para enviar dados ao AppSignal usando atributos de recurso.

Atributos de recurso são atributos que se aplicam a cada trace reportado pela aplicação usando OpenTelemetry.

Você pode configurar atributos de recurso no seu arquivo de configuração do OpenTelemetry; é também onde você precisa configurar o exporter do OpenTelemetry para enviar dados ao [AppSignal collector](/opentelemetry/installation).

<CodeGroup>
  ```go Go theme={null}
  import (
  	// Outros imports ....
  	"go.opentelemetry.io/otel/sdk/resource"
  	semconv "go.opentelemetry.io/otel/semconv/v1.27.0"
  	sdktrace "go.opentelemetry.io/otel/sdk/trace"
  )

  res := resource.NewSchemaless(
  	// Adicione atributos de recurso aqui
  	semconv.ServiceNameKey.String("My service name"),
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My app name")),
  )

  tp := sdktrace.NewTracerProvider(
  	// Outras chamadas .With...
  	sdktrace.WithResource(res),
  )
  ```
</CodeGroup>

## Nome do app

* Nome do atributo: `appsignal.config.name`
* Ou como cabeçalho da requisição: `Appsignal-Config-Name`
* Tipo: String
* Obrigatório: Sim

Nome da sua aplicação como deve ser exibido no AppSignal.com.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.name": "My awesome app",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My awesome app")),
  )
  ```
</CodeGroup>

## Ambiente do app

* Nome do atributo: `appsignal.config.environment`
* Ou como cabeçalho da requisição: `Appsignal-Config-Environment`
* Tipo: String
* Obrigatório: Sim

O ambiente da aplicação como deve ser exibido no AppSignal.com.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
  # Adicione esta linha aos atributos de recurso
  "appsignal.config.environment": "staging",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.environment", "production")),
  )
  ```
</CodeGroup>

## Push API key

* Nome do atributo: `appsignal.config.push_api_key`
* Ou como cabeçalho da requisição: `Appsignal-Config-PushApiKey`
* Tipo: String
* Obrigatório: Sim

A chave de autenticação no nível da organização para autenticar com nossa Push API.

Para informações detalhadas sobre a [Push API key do AppSignal](/appsignal/terminology#push-api-key), consulte nossa documentação de terminologia.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.push_api_key": "00000000-0000-0000-0000-000000000000",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.push_api_key", "00000000-0000-0000-0000-000000000000")),
  )
  ```
</CodeGroup>

## Revisão do app

* Nome do atributo: `appsignal.config.revision`
* Ou como cabeçalho da requisição: `Appsignal-Config-Revision`
* Tipo: String
* Obrigatório: Sim

Para reportar novas implantações de aplicações OpenTelemetry, você pode usar [Deploy Markers](/application/markers/deploy-markers).

Deploy markers podem ser configurados com o atributo de recurso de revisão. O valor desse atributo será usado para identificar novas implantações. Ele precisa ser único por implantação para detectar novas implantações. Recomendamos usar SHAs de commits Git ou uma tag no seu SCM. Isso pode ser usado em combinação com nossos [backtrace links](/application/backtrace-links) para vincular diretamente do AppSignal de volta ao código-fonte em plataformas como GitHub e GitLab.

<CodeGroup>
  ```python Python theme={null}
  import subprocess

  attributes = {
      # ...
  }

  try:
    revision = subprocess.check_output("git rev-parse --short HEAD", shell=True, text=True).strip()
    attributes["appsignal.config.revision"] = revision
  except subprocess.CalledProcessError:
    pass

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os/exec"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  var revision string
  cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
  output, err := cmd.Output()
  if err != nil {
  	revision = "unknown"
  } else {
  	revision = strings.TrimSpace(string(output))
  }

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.revision", revision)),
  )
  ```
</CodeGroup>

## Integração de linguagem

* Nome do atributo: `appsignal.config.language_integration`
* Ou como cabeçalho da requisição: `Appsignal-Config-LanguageIntegration`
* Tipo: String
* Obrigatório: Sim

O AppSignal usa o atributo de recurso `language_integration` para detectar a linguagem de um trace e analisar corretamente os backtraces de exceções.

Para definir essa opção, especifique o nome da linguagem em minúsculas, por exemplo, "python", "rust", "ruby", "elixir", "go" e "nodejs".

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.language_integration": "python",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.language_integration", "go")),
  )
  ```
</CodeGroup>

## Nome do app OTP

* Nome do atributo: `appsignal.config.otp_app`
* Tipo: String
* Obrigatório: Sim, para apps Elixir

O AppSignal usa o atributo de recurso `appsignal.config.otp_app` para detectar quais linhas de backtrace de erros pertencem à aplicação.

Você pode encontrar o nome do app OTP da sua aplicação chamando `IO.inspect(:application.get_application())` na sua aplicação e verificando a saída.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :opentelemetry,
    resource: [
      {"appsignal.config.otp_app", "OTP app name"},
      # E outros atributos de recurso
    ]
  ```
</CodeGroup>

## Nome do serviço

* Nome do atributo: `service.name`
* Ou como cabeçalho da requisição: `OpenTelemetry-ServiceName`
* Tipo: String
* Obrigatório: Sim

O atributo de recurso `service.name` ajuda o AppSignal a reconhecer diferentes serviços para traces e agrupa os traces automaticamente em um namespace baseado no nome do serviço.

Escolha um nome que se encaixe na sua aplicação, como "Web server", "Background worker", "Email service", "Authentication service", etc.

<CodeGroup>
  ```python Python theme={null}
  import socket

  attributes = {
      # Adicione esta linha aos atributos de recurso
      "service.name": "My service name",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("service.name", "My service name")),
  )
  ```
</CodeGroup>

## Hostname

* Nome do atributo: `host.name`
* Ou como cabeçalho da requisição: `OpenTelemetry-HostName`
* Tipo: String
* Obrigatório: Sim

O atributo de recurso `host.name` ajuda o AppSignal a reconhecer diferentes hosts para traces e tagueia os traces automaticamente com o hostname.

<CodeGroup>
  ```python Python theme={null}
  import socket

  attributes = {
      # Adicione esta linha aos atributos de recurso
      "host.name": socket.gethostname(),
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  hostname, err := os.Hostname()
  if err != nil {
  	hostname = "unknown"
  }

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("host.name", hostname)),
  )
  ```
</CodeGroup>

## Caminho do app

* Nome do atributo: `appsignal.config.app_path`
* Tipo: String
* Obrigatório: Não

A localização do app no sistema de arquivos do host.

O atributo de recurso `app_path` ajuda o AppSignal a limpar backtraces removendo o caminho absoluto do app das linhas de backtrace. Dessa forma, somente os caminhos dentro do contexto do diretório do projeto são exibidos. Isso torna possível nosso recurso de [Backtrace links](/application/backtrace-links).

<CodeGroup>
  ```python Python theme={null}
  import os

  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.app_path": os.getcwd()
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	resource.WithAttributes(attribute.String("appsignal.config.app_path", os.Getenv("PWD"))),
  )
  ```
</CodeGroup>

## Filter attributes

* Nome do atributo: `appsignal.config.filter_attributes`
* Tipo: Array
* Obrigatório: Não

O atributo de recurso `filter_attributes` permite filtrar atributos específicos para que não sejam reportados ao AppSignal. Isso pode ser útil para filtrar informações sensíveis ou irrelevantes para que não sejam reportadas.

Se um atributo for filtrado dessa forma, ele não aparecerá na interface.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.filter_attributes": ["my.secret.attribute", "some.opentelemetry.attribute"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.filter_attributes", []string{"my.secret.attribute", "some.opentelemetry.attribute"}),
  )
  ```
</CodeGroup>

## Filter function parameters

* Nome do atributo: `appsignal.config.filter_function_parameters`
* Tipo: Array
* Valor padrão: *Vazio*
* Obrigatório: Não

O atributo de recurso `filter_function_parameters` permite filtrar quaisquer parâmetros de função definidos no [atributo de span `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters).

No exemplo abaixo, os valores para as chaves listadas na opção de configuração `filter_function_parameters` são substituídos por `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configure o recurso do exporter assim:
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.filter_function_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Resto da configuração do exporter...

  # Em seguida, no trace, defina o atributo de span dos parâmetros da função
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.function.parameters", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure o recurso do exporter assim:
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.filter_function_parameters", []string{"password", "cvv"}),
  )
  // Resto da configuração do exporter...

  // Em seguida, no trace, defina o atributo de span dos parâmetros da função
  import (
  	"encoding/json"

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

  // O contexto precisa conter o span ativo que você planeja extrair
  // Como `c.Request.Context()` para apps gin
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.function.parameters", string(json)))
  ```
</CodeGroup>

## Filter request query parameters

* Nome do atributo: `appsignal.config.filter_request_query_parameters`
* Tipo: Array
* Valor padrão: *Vazio*
* Obrigatório: Não

O atributo de recurso `filter_request_query_parameters` permite filtrar quaisquer query parameters de requisição definidos no [atributo de span `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

No exemplo abaixo, os valores para as chaves listadas na opção de configuração `filter_request_query_parameters` são substituídos por `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configure o recurso do exporter assim:
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.filter_request_query_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Resto da configuração do exporter...

  # Em seguida, no trace, defina o atributo de span dos query parameters
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.query_parameters", json.dumps({
          "password": "super secret",
          "test_param": "test value"
      }))
  ```

  ```go Go theme={null}
  // Configure o recurso do exporter assim:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.filter_request_query_parameters", []string{"password", "cvv"}),
  )
  // Resto da configuração do exporter...

  // Em seguida, no trace, defina o atributo de span dos query parameters
  import (
  	"encoding/json"

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

  // O contexto precisa conter o span ativo que você planeja extrair
  // Como `c.Request.Context()` para apps gin
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.query_parameters", string(json)))
  ```
</CodeGroup>

## Filter request payload

* Nome do atributo: `appsignal.config.filter_request_payload`
* Tipo: Array
* Valor padrão: *Vazio*
* Obrigatório: Não

O atributo de recurso `filter_request_payload` permite filtrar quaisquer dados de payload de requisição definidos no [atributo de span `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload).

No exemplo abaixo, os valores para as chaves listadas na opção de configuração `filter_request_payload` são substituídos por `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configure o recurso do exporter assim:
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.filter_request_payload": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Resto da configuração do exporter...

  # Em seguida, no trace, defina o atributo de span do payload da requisição
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.payload", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure o recurso do exporter assim:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.filter_request_payload", []string{"password", "cvv"}),
  )
  // Resto da configuração do exporter...

  // Em seguida, no trace, defina o atributo de span dos parâmetros da função
  import (
  	"encoding/json"

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

  // O contexto precisa conter o span ativo que você planeja extrair
  // Como `c.Request.Context()` para apps gin
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.payload", string(json)))
  ```
</CodeGroup>

## Filter request session data

* Nome do atributo: `appsignal.config.filter_request_session_data`
* Tipo: Array
* Valor padrão: *Vazio*
* Obrigatório: Não

O atributo de recurso `filter_request_session_data` permite filtrar quaisquer dados de sessão de requisição definidos no [atributo de span `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data).

No exemplo abaixo, os valores para as chaves listadas na opção de configuração `filter_request_session_data` são substituídos por `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configure o recurso do exporter assim:
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.filter_request_session_data": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Resto da configuração do exporter...

  # Em seguida, no trace, defina o atributo de span dos dados de sessão
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.session_data", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure o recurso do exporter assim:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.filter_session_data", []string{"password", "cvv"}),
  )
  // Resto da configuração do exporter...

  // Em seguida, no trace, defina o atributo de span dos parâmetros de dados de sessão
  import (
  	"encoding/json"

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

  // O contexto precisa conter o span ativo que você planeja extrair
  // Como `c.Request.Context()` para apps gin
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  sessionData := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(sessionData)
  span.SetAttributes(attribute.String("appsignal.request.session_data", string(json)))
  ```
</CodeGroup>

## Ignore actions

* Nome do atributo: `appsignal.config.ignore_actions`
* Tipo: Array de Strings
* Obrigatório: Não

O atributo de recurso `ignore_actions` permite ignorar ações específicas para que não sejam reportadas ao AppSignal. Isso pode ser útil para ignorar endpoints de health check ou outras ações que você não quer monitorar.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.ignore_actions": ["GET /health_check", "POST /ping"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.ignore_actions", []string{"GET /heath_check", "POST /ping"}),
  )
  ```
</CodeGroup>

## Ignore errors

* Nome do atributo: `appsignal.config.ignore_errors`
* Tipo: Array de Strings
* Obrigatório: Não

O atributo de recurso `ignore_errors` permite ignorar erros específicos para que não sejam reportados ao AppSignal. Isso pode ser útil para ignorar erros esperados ou erros que não podem ser resolvidos.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.ignore_errors": ["MyCustomError", "ExpectedError"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.ignore_errors", []string{"MyCustomError", "ExpectedError"}),
  )
  ```
</CodeGroup>

## Ignore namespaces

* Nome do atributo: `appsignal.config.ignore_namespaces`
* Tipo: Array de Strings
* Obrigatório: Não

O atributo de recurso `ignore_namespaces` permite ignorar namespaces específicos para que não sejam reportados ao AppSignal. Isso pode ser útil para ignorar partes específicas da sua aplicação que você não quer que sejam monitoradas.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.ignore_namespaces": ["admin" ,"secret"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Outros atributos de recurso
  	attribute.StringSlice("appsignal.config.ignore_namespaces", []string{"admin", "secret"}),
  )
  ```
</CodeGroup>

## Cabeçalhos de resposta

* Nome do atributo: `appsignal.config.response_headers`
* Tipo: Array de Strings
* Valor padrão: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Obrigatório: Não

Configure quais cabeçalhos de resposta incluir quando uma requisição é feita por um cliente HTTP. Esta opção é uma allowlist. Ela só inclui os cabeçalhos que foram configurados. Se a lista estiver vazia, nenhum cabeçalho é incluído.

Os cabeçalhos de resposta são lidos dos [atributos de span do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.response.header.<key>`, onde `<key>` é o nome do cabeçalho normalizado (em minúsculas).

Para não definir nenhum cabeçalho, defina explicitamente o valor do atributo de recurso como um array vazio.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Envia apenas estes cabeçalhos específicos
      "appsignal.config.response_headers": ["accept", "request_method", "content_length"]

      # Não envia nenhum cabeçalho
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Envia apenas estes cabeçalhos específicos
  	attribute.StringSlice("appsignal.config.response_headers", []string{"accept", "request_method", "content_length"}),

  	// Não envia nenhum cabeçalho
  	attribute.StringSlice("appsignal.config.response_headers", []string{}),
  )
  ```
</CodeGroup>

## Cabeçalhos de requisição

* Nome do atributo: `appsignal.config.request_headers`
* Tipo: Array de Strings
* Valor padrão: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Obrigatório: Não

Configure quais cabeçalhos de requisição incluir quando uma requisição é feita a um servidor HTTP. Esta opção é uma allowlist. Ela só inclui os cabeçalhos que foram configurados. Se a lista estiver vazia, nenhum cabeçalho é incluído.

Os cabeçalhos de requisição são lidos dos [atributos de span do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.request.header.<key>`, onde `<key>` é o nome do cabeçalho normalizado (em minúsculas).

Para não definir nenhum cabeçalho, defina explicitamente o valor do atributo de recurso como um array vazio.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Envia apenas estes cabeçalhos específicos
      "appsignal.config.request_headers": ["accept", "request_method", "content_length"]

      # Não envia nenhum cabeçalho
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Envia apenas estes cabeçalhos específicos
  	attribute.StringSlice("appsignal.config.request_headers", []string{"accept", "request_method", "content_length"}),

  	// Não envia nenhum cabeçalho
  	attribute.StringSlice("appsignal.config.request_headers", []string{}),
  )
  ```
</CodeGroup>

## Send function parameters

* Nome do atributo: `appsignal.config.send_function_parameters`
* Tipo: Boolean
* Valor padrão: `true`
* Obrigatório: Não

Configure se deve incluir parâmetros de função nos traces. Se definido como `false`, nenhum desses dados é enviado aos nossos servidores.

Esses valores são definidos com o [atributo de span `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.send_function_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Adicione esta linha aos atributos de recurso
  	attribute.Bool("appsignal.config.send_function_parameters", false),
  )
  ```
</CodeGroup>

## Send request query parameter

* Nome do atributo: `appsignal.config.send_request_query_parameters`
* Tipo: Boolean
* Valor padrão: `true`
* Obrigatório: Não

Configure se deve incluir query parameters de requisição nos traces. Se definido como `false`, nenhum desses dados é enviado aos nossos servidores.

Esses valores são definidos com o [atributo de span `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

Para mais informações, leia sobre [filtragem de parâmetros de requisição](/application/parameter-filtering).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.send_request_query_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Adicione esta linha aos atributos de recurso
  	attribute.Bool("appsignal.config.send_request_query_parameters", false),
  )
  ```
</CodeGroup>

## Send request payload

* Nome do atributo: `appsignal.config.send_request_payload`
* Tipo: Boolean
* Valor padrão: `true`
* Obrigatório: Não

Configure se deve enviar dados do payload da requisição nos traces. Se definido como `false`, nenhum desses dados é enviado aos nossos servidores.

Esses valores são definidos com o [atributo de span `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.send_request_payload": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Adicione esta linha aos atributos de recurso
  	attribute.Bool("appsignal.config.send_request_payload", false),
  )
  ```
</CodeGroup>

## Send request session data

* Nome do atributo: `appsignal.config.send_request_session_data`
* Tipo: Boolean
* Valor padrão: `true`
* Obrigatório: Não

Configure se deve enviar dados de sessão da requisição nos traces. Se definido como `false`, nenhum desses dados é enviado aos nossos servidores.

Esses valores são definidos com o [atributo de span `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Adicione esta linha aos atributos de recurso
      "appsignal.config.send_request_session_data": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Adicione esta linha aos atributos de recurso
  	attribute.Bool("appsignal.config.send_session_data", false),
  )
  ```
</CodeGroup>