From 46a1eb107f759ca39d2ce67b0e80942a273f79ea Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Mon, 24 Feb 2025 22:23:46 -0300
Subject: [PATCH 1/7] feat: add localization python instrumentation

---
 .../docs/languages/python/instrumentation.md  | 409 ++++++++++++++++++
 1 file changed, 409 insertions(+)
 create mode 100644 content/pt/docs/languages/python/instrumentation.md

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
new file mode 100644
index 000000000000..2853c473e02d
--- /dev/null
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -0,0 +1,409 @@
+---
+title: Instrumentação
+aliases: [manual]
+weight: 20
+description: Instrumentação manual para OpenTelemetry Python
+cSpell:ignore: millis ottrace textmap
+---
+
+<!-- markdownlint-disable no-duplicate-heading -->
+
+{{% include instrumentation-intro.md %}}
+
+## Configuração {#setup}
+
+Primeiro, certifique-se de ter os pacotes da API e SDK:
+
+```shell
+pip install opentelemetry-api
+pip install opentelemetry-sdk
+```
+
+## Rastros {#traces}
+
+### Obter um Rastreador {#acquire-tracer}
+
+Para começar a rastrear, você precisará inicializar um
+[`TracerProvider`](/docs/concepts/signals/traces/#tracer-provider) e
+opcionalmente defini-lo como o padrão global.
+
+```python
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    ConsoleSpanExporter,
+)
+
+provider = TracerProvider()
+processor = BatchSpanProcessor(ConsoleSpanExporter())
+provider.add_span_processor(processor)
+
+# Define o provedor de rastreador global padrão
+trace.set_tracer_provider(provider)
+
+# Cria um rastreador a partir do provedor de rastreador global
+tracer = trace.get_tracer("meu.rastreador.nome")
+```
+
+### Criando Trechos {#creating-spans}
+
+Para criar um [trecho](/docs/concepts/signals/traces/#spans), geralmente você
+desejará iniciá-lo como o trecho atual.
+
+```python
+def fazer_trabalho():
+    with tracer.start_as_current_span("nome-do-trecho") as span:
+        # faça algum trabalho que 'span' irá rastrear
+        print("fazendo algum trabalho...")
+        # Quando o bloco 'with' sair do escopo, 'span' será fechado para você
+```
+
+Você também pode usar `start_span` para criar um trecho sem torná-lo o trecho
+atual. Isso geralmente é feito para rastrear operações concorrentes ou
+assíncronas.
+
+### Criando Trechos Aninhados {#creating-nested-spans}
+
+Se você tiver uma sub-operação distinta que gostaria de rastrear como parte de
+outra, você pode criar [trechos](/docs/concepts/signals/traces/#spans) para
+representar a relação:
+
+```python
+def fazer_trabalho():
+    with tracer.start_as_current_span("pai") as parent:
+        # faça algum trabalho que 'pai' rastreia
+        print("fazendo algum trabalho...")
+        # Crie um trecho aninhado para rastrear trabalho aninhado
+        with tracer.start_as_current_span("filho") as child:
+            # faça algum trabalho que 'filho' rastreia
+            print("fazendo algum trabalho aninhado...")
+            # o trecho aninhado é fechado quando sai do escopo
+
+        # Este trecho também é fechado quando sai do escopo
+```
+
+Quando você visualizar trechos em uma ferramenta de visualização de rastros,
+`filho` será rastreado como um trecho aninhado sob `pai`.
+
+### Criando Trechos com Decoradores {#creating-spans-with-decorators}
+
+É comum ter um único [trecho](/docs/concepts/signals/traces/#spans) rastreando
+a execução de uma função inteira. Nesse cenário, há um decorador que você pode
+usar para reduzir o código:
+
+```python
+@tracer.start_as_current_span("fazer_trabalho")
+def fazer_trabalho():
+    print("fazendo algum trabalho...")
+```
+
+O uso do decorador é equivalente a criar o trecho dentro de `fazer_trabalho()` e
+finalizá-lo quando `fazer_trabalho()` for concluído.
+
+Para usar o decorador, você deve ter uma instância de `tracer` disponível
+globalmente para a declaração da sua função.
+
+### Obter o Trecho Atual {#get-the-current-span}
+
+Às vezes, é útil acessar o [trecho](/docs/concepts/signals/traces/#spans) atual em um ponto no tempo para que você
+possa enriquecê-lo com mais informações.
+
+```python
+from opentelemetry import trace
+
+current_span = trace.get_current_span()
+# enriqueça 'current_span' com algumas informações
+```
+
+### Adicionar Atributos em um Trecho {#add-attributes-to-a-span}
+
+[Atributos](/docs/concepts/signals/traces/#attributes) permitem que você anexe
+pares chave/valor em um [trecho](/docs/concepts/signals/traces/#spans) para transportar mais informações sobre a operação atual que está sendo rastreada.
+
+```python
+from opentelemetry import trace
+
+current_span = trace.get_current_span()
+
+current_span.set_attribute("valor.operacao", 1)
+current_span.set_attribute("nome.operacao", "Dizendo olá!")
+current_span.set_attribute("outras-coisas.operacao", [1, 2, 3])
+```
+
+### Adicionar Atributos Semânticos {#add-semantic-attributes}
+
+Os [Atributos Semânticos](/docs/specs/semconv/general/trace/) são
+[Atributos](/docs/concepts/signals/traces/#attributes) predeterminados, que são
+convenções de nomenclatura bastante conhecidas para tipos comuns de dados. Usar
+Atributos Semânticos permite que você normalize esse tipo de informação em seus
+sistemas.
+
+Para usar Atributos Semânticos em Python, certifique-se de ter o pacote de
+convenções semânticas:
+
+```shell
+pip install opentelemetry-semantic-conventions
+```
+
+Então você pode usá-lo no código:
+
+```python
+from opentelemetry import trace
+from opentelemetry.semconv.trace import SpanAttributes
+
+// ...
+
+current_span = trace.get_current_span()
+current_span.set_attribute(SpanAttributes.HTTP_METHOD, "GET")
+current_span.set_attribute(SpanAttributes.HTTP_URL, "https://opentelemetry.io/")
+```
+
+### Adicionando Eventos {#adding-events}
+
+Um [evento](/docs/concepts/signals/traces/#span-events) é uma mensagem legível
+por humanos em um [trecho](/docs/concepts/signals/traces/#spans) que representa
+"algo está acontecendo" durante sua vida. Você pode pensar nisso como um log
+primitivo.
+
+```python
+from opentelemetry import trace
+
+current_span = trace.get_current_span()
+
+current_span.add_event("Vou tentar!")
+
+# Faça alguma coisa
+
+current_span.add_event("Consegui!")
+```
+
+### Adicionando Links {#adding-links}
+
+Um [trecho](/docs/concepts/signals/traces/#spans) pode ser criado com zero ou
+mais [links de trecho](/docs/concepts/signals/traces/#span-links) que o ligam
+causalmente a outro trecho. Um link precisa de um contexto de trecho para ser
+criado.
+
+```python
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+with tracer.start_as_current_span("trecho-1"):
+    # Faça algo que 'trecho-1' rastreia.
+    ctx = trace.get_current_span().get_span_context()
+    link_from_span_1 = trace.Link(ctx)
+
+with tracer.start_as_current_span("trecho-2", links=[link_from_span_1]):
+    # Faça algo que 'trecho-2' rastreia.
+    # O link em 'trecho-2' está causalmente associado ao 'trecho-1',
+    # mas não é um trecho filho.
+    pass
+```
+
+### Definir Status do Trecho {#set-span-status}
+
+{{% docs/languages/span-status-preamble %}}
+
+```python
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+
+current_span = trace.get_current_span()
+
+try:
+    # algo que pode falhar
+except:
+    current_span.set_status(Status(StatusCode.ERROR))
+```
+
+### Registrar Exceções em Trechos {#record-exceptions-in-spans}
+
+Pode ser uma boa ideia registrar exceções quando elas acontecem. Recomenda-se
+fazer isso em conjunto com a definição do [status do trecho](#set-span-status).
+
+```python
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+
+current_span = trace.get_current_span()
+
+try:
+    # algo que pode falhar
+
+# Considere capturar uma exceção mais específica em seu código
+except Exception as ex:
+    current_span.set_status(Status(StatusCode.ERROR))
+    current_span.record_exception(ex)
+```
+
+### Alterar o Formato de Propagação Padrão {#change-the-default-propagation-format}
+
+Por padrão, o OpenTelemetry Python usará os seguintes formatos de propagação:
+
+- W3C Trace Context
+- W3C Baggage
+
+Se você precisar alterar os padrões, pode fazê-lo por meio de variáveis de
+ambiente ou no código:
+
+#### Usando Variáveis de Ambiente
+
+Você pode definir a variável de ambiente `OTEL_PROPAGATORS` com uma lista
+separada por vírgulas. Os valores aceitos são:
+
+- `"tracecontext"`: W3C Trace Context
+- `"baggage"`: W3C Baggage
+- `"b3"`: B3 Single
+- `"b3multi"`: B3 Multi
+- `"jaeger"`: Jaeger
+- `"xray"`: AWS X-Ray (terceiros)
+- `"ottrace"`: OT Trace (terceiros)
+- `"none"`: Nenhum propagador configurado automaticamente.
+
+A configuração padrão é equivalente a
+`OTEL_PROPAGATORS="tracecontext,baggage"`.
+
+#### Usando APIs do SDK {#using-sdk-apis}
+
+Como alternativa, você pode alterar o formato no código.
+
+Por exemplo, se você precisar usar o formato de propagação B3 do Zipkin, pode
+instalar o pacote B3:
+
+```shell
+pip install opentelemetry-propagator-b3
+```
+
+E então definir o propagador B3 no seu código de inicialização de rastreamento:
+
+```python
+from opentelemetry.propagate import set_global_textmap
+from opentelemetry.propagators.b3 import B3Format
+
+set_global_textmap(B3Format())
+```
+
+Observe que as variáveis de ambiente substituirão o que está configurado no
+código.
+
+### Leituras Adicionais {#further-reading}
+
+- [Conceitos de Rastros](/docs/concepts/signals/traces/)
+- [Especificação de Rastros](/docs/specs/otel/overview/#tracing-signal)
+- [Documentação da API de Rastros do Python](https://opentelemetry-python.readthedocs.io/en/latest/api/trace.html)
+- [Documentação do SDK de Rastros do Python](https://opentelemetry-python.readthedocs.io/en/latest/sdk/trace.html)
+
+## Métricas {#metrics}
+
+Para começar a coletar métricas, você precisará inicializar um
+[`MeterProvider`](/docs/specs/otel/metrics/api/#meterprovider) e opcionalmente
+defini-lo como o padrão global.
+
+```python
+from opentelemetry import metrics
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import (
+    ConsoleMetricExporter,
+    PeriodicExportingMetricReader,
+)
+
+metric_reader = PeriodicExportingMetricReader(ConsoleMetricExporter())
+provider = MeterProvider(metric_readers=[metric_reader])
+
+# Define o provedor de medidor global padrão
+metrics.set_meter_provider(provider)
+
+# Cria um medidor a partir do provedor de medidor global
+meter = metrics.get_meter("meu.medidor.nome")
+```
+
+### Criando e Usando Instrumentos Síncronos
+
+Os instrumentos são usados para fazer medições do seu aplicativo.
+[Instrumentos síncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
+são usados em linha com a lógica de processamento de aplicativos/negócios, como
+ao lidar com uma solicitação ou chamar outro serviço.
+
+Primeiro, crie seu instrumento. Os instrumentos geralmente são criados uma vez
+no nível do módulo ou da classe e depois usados em linha com a lógica de
+negócios. Este exemplo usa um instrumento
+[Counter](/docs/specs/otel/metrics/api/#counter) para contar o número de itens
+de trabalho concluídos:
+
+```python
+work_counter = meter.create_counter(
+    "contador.trabalho", unit="1", description="Conta a quantidade de trabalho feito"
+)
+```
+
+Usando a [operação de adição](/docs/specs/otel/metrics/api/#add) do Counter, o
+código abaixo incrementa a contagem em um, usando o tipo de item de trabalho
+como um atributo.
+
+```python
+def fazer_trabalho(item_trabalho):
+    # conta o trabalho sendo feito
+    work_counter.add(1, {"tipo.trabalho": item_trabalho.tipo_trabalho})
+    print("fazendo algum trabalho...")
+```
+
+### Criando e Usando Instrumentos Assíncronos {#creating-and-using-asynchronous-instruments}
+
+[Instrumentos assíncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
+dão ao usuário uma maneira de registrar funções de _callback_, que são invocadas
+sob demanda para fazer medições. Isso é útil para medir periodicamente um valor
+que não pode ser instrumentado diretamente. Os instrumentos assíncronos são
+criados com zero ou mais callbacks que serão invocados durante a coleta de
+métricas. Cada callback aceita opções do SDK e retorna suas observações.
+
+Este exemplo usa um instrumento
+[Gauge Assíncrono](/docs/specs/otel/metrics/api/#asynchronous-gauge) para
+relatar a versão de configuração atual fornecida por um servidor de
+configuração, raspando um endpoint HTTP. Primeiro, escreva um callback para
+fazer observações:
+
+```python
+from typing import Iterable
+from opentelemetry.metrics import CallbackOptions, Observation
+
+
+def raspar_versoes_configuracao(options: CallbackOptions) -> Iterable[Observation]:
+    r = requests.get(
+        "http://configserver/version_metadata", timeout=options.timeout_millis / 10**3
+    )
+    for metadata in r.json():
+        yield Observation(
+            metadata["version_num"], {"config.name": metadata["version_num"]}
+        )
+```
+
+Observe que o OpenTelemetry passará opções para seu callback contendo um
+timeout. Os callbacks devem respeitar esse timeout para evitar bloqueios
+indefinidos. Finalmente, crie o instrumento com o callback para registrá-lo:
+
+```python
+meter.create_observable_gauge(
+    "config.versao",
+    callbacks=[raspar_versoes_configuracao],
+    description="A versão de configuração ativa para cada configuração",
+)
+```
+
+### Leituras Adicionais {#further-reading}
+
+- [Conceitos de Métricas](/docs/concepts/signals/metrics/)
+- [Especificação de Métricas](/docs/specs/otel/metrics/)
+- [Documentação da API de Métricas do Python](https://opentelemetry-python.readthedocs.io/en/latest/api/metrics.html)
+- [Documentação do SDK de Métricas do Python](https://opentelemetry-python.readthedocs.io/en/latest/sdk/metrics.html)
+
+## Logs {#logs}
+
+A API e o SDK de logs estão atualmente em desenvolvimento.
+
+## Próximos Passos {#next-steps}
+
+Você também desejará configurar um exportador apropriado para
+[exportar seus dados de telemetria](/docs/languages/python/exporters) para um
+ou mais backends de telemetria.

From e06921d91c2fbef2380e7ca5eec67ce1bb0e05e3 Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Thu, 27 Feb 2025 08:04:18 -0300
Subject: [PATCH 2/7] fix: run lint

---
 .../docs/languages/python/instrumentation.md  | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index 2853c473e02d..769b87f67236 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -4,6 +4,7 @@ aliases: [manual]
 weight: 20
 description: Instrumentação manual para OpenTelemetry Python
 cSpell:ignore: millis ottrace textmap
+default_lang_commit: c3365f297f394baf10f5dba3473e13621ade4461
 ---
 
 <!-- markdownlint-disable no-duplicate-heading -->
@@ -49,7 +50,7 @@ tracer = trace.get_tracer("meu.rastreador.nome")
 ### Criando Trechos {#creating-spans}
 
 Para criar um [trecho](/docs/concepts/signals/traces/#spans), geralmente você
-desejará iniciá-lo como o trecho atual.
+pretende iniciá-lo como o trecho atual.
 
 ```python
 def fazer_trabalho():
@@ -88,8 +89,8 @@ Quando você visualizar trechos em uma ferramenta de visualização de rastros,
 
 ### Criando Trechos com Decoradores {#creating-spans-with-decorators}
 
-É comum ter um único [trecho](/docs/concepts/signals/traces/#spans) rastreando
-a execução de uma função inteira. Nesse cenário, há um decorador que você pode
+É comum ter um único [trecho](/docs/concepts/signals/traces/#spans) rastreando a
+execução de uma função inteira. Nesse cenário, há um decorador que você pode
 usar para reduzir o código:
 
 ```python
@@ -102,12 +103,12 @@ O uso do decorador é equivalente a criar o trecho dentro de `fazer_trabalho()`
 finalizá-lo quando `fazer_trabalho()` for concluído.
 
 Para usar o decorador, você deve ter uma instância de `tracer` disponível
-globalmente para a declaração da sua função.
+globalmente para a declarar sua função.
 
 ### Obter o Trecho Atual {#get-the-current-span}
 
-Às vezes, é útil acessar o [trecho](/docs/concepts/signals/traces/#spans) atual em um ponto no tempo para que você
-possa enriquecê-lo com mais informações.
+Às vezes, é útil acessar o [trecho](/docs/concepts/signals/traces/#spans) atual
+em um ponto no tempo para que você possa enriquecê-lo com mais informações.
 
 ```python
 from opentelemetry import trace
@@ -118,8 +119,9 @@ current_span = trace.get_current_span()
 
 ### Adicionar Atributos em um Trecho {#add-attributes-to-a-span}
 
-[Atributos](/docs/concepts/signals/traces/#attributes) permitem que você anexe
-pares chave/valor em um [trecho](/docs/concepts/signals/traces/#spans) para transportar mais informações sobre a operação atual que está sendo rastreada.
+Os [Atributos](/docs/concepts/signals/traces/#attributes) permitem que você
+anexe pares de chave/valor em um [trecho](/docs/concepts/signals/traces/#spans)
+para transportar mais informações sobre a operação que está sendo rastreada.
 
 ```python
 from opentelemetry import trace
@@ -135,9 +137,8 @@ current_span.set_attribute("outras-coisas.operacao", [1, 2, 3])
 
 Os [Atributos Semânticos](/docs/specs/semconv/general/trace/) são
 [Atributos](/docs/concepts/signals/traces/#attributes) predeterminados, que são
-convenções de nomenclatura bastante conhecidas para tipos comuns de dados. Usar
-Atributos Semânticos permite que você normalize esse tipo de informação em seus
-sistemas.
+nomenclatura bastante conhecidas para tipos comuns de dados. Usar Atributos
+Semânticos permite que você normalize esse tipo de informação em seus sistemas.
 
 Para usar Atributos Semânticos em Python, certifique-se de ter o pacote de
 convenções semânticas:
@@ -262,8 +263,7 @@ separada por vírgulas. Os valores aceitos são:
 - `"ottrace"`: OT Trace (terceiros)
 - `"none"`: Nenhum propagador configurado automaticamente.
 
-A configuração padrão é equivalente a
-`OTEL_PROPAGATORS="tracecontext,baggage"`.
+A configuração padrão é equivalente a `OTEL_PROPAGATORS="tracecontext,baggage"`.
 
 #### Usando APIs do SDK {#using-sdk-apis}
 
@@ -352,10 +352,10 @@ def fazer_trabalho(item_trabalho):
 ### Criando e Usando Instrumentos Assíncronos {#creating-and-using-asynchronous-instruments}
 
 [Instrumentos assíncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
-dão ao usuário uma maneira de registrar funções de _callback_, que são invocadas
-sob demanda para fazer medições. Isso é útil para medir periodicamente um valor
-que não pode ser instrumentado diretamente. Os instrumentos assíncronos são
-criados com zero ou mais callbacks que serão invocados durante a coleta de
+fornece ao usuário uma maneira de registrar funções de _callback_, que são
+invocadas sob demanda para fazer medições. Isso é útil para medir periodicamente
+um valor que não pode ser instrumentado diretamente. Os instrumentos assíncronos
+são criados com zero ou mais callbacks que serão invocados durante a coleta de
 métricas. Cada callback aceita opções do SDK e retorna suas observações.
 
 Este exemplo usa um instrumento
@@ -405,5 +405,5 @@ A API e o SDK de logs estão atualmente em desenvolvimento.
 ## Próximos Passos {#next-steps}
 
 Você também desejará configurar um exportador apropriado para
-[exportar seus dados de telemetria](/docs/languages/python/exporters) para um
-ou mais backends de telemetria.
+[exportar seus dados de telemetria](/docs/languages/python/exporters) para um ou
+mais backends de telemetria.

From 27575972edd7bdcc75cc20397913cacf919fbc93 Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Thu, 27 Feb 2025 08:12:06 -0300
Subject: [PATCH 3/7] fix: run fix dict

---
 content/pt/docs/languages/python/instrumentation.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index 769b87f67236..90c99a8a1122 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -3,8 +3,8 @@ title: Instrumentação
 aliases: [manual]
 weight: 20
 description: Instrumentação manual para OpenTelemetry Python
-cSpell:ignore: millis ottrace textmap
 default_lang_commit: c3365f297f394baf10f5dba3473e13621ade4461
+cSpell:ignore: millis ottrace textmap
 ---
 
 <!-- markdownlint-disable no-duplicate-heading -->

From 225d21b195a9a828bf07563553e3ca46d34612ed Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Fri, 14 Mar 2025 20:54:48 -0300
Subject: [PATCH 4/7] fix: aceita sugestao

---
 content/pt/docs/languages/python/instrumentation.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index 90c99a8a1122..987504a7cb36 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -321,10 +321,11 @@ meter = metrics.get_meter("meu.medidor.nome")
 
 ### Criando e Usando Instrumentos Síncronos
 
-Os instrumentos são usados para fazer medições do seu aplicativo.
-[Instrumentos síncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
-são usados em linha com a lógica de processamento de aplicativos/negócios, como
-ao lidar com uma solicitação ou chamar outro serviço.
+Os
+[instrumentos síncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
+são usados para fazer medições do seu aplicativo e são usados em linha com a
+lógica de processamento de aplicativos/negócios, como ao lidar com uma
+solicitação ou chamar outro serviço.
 
 Primeiro, crie seu instrumento. Os instrumentos geralmente são criados uma vez
 no nível do módulo ou da classe e depois usados em linha com a lógica de

From 1d444bfa9f278af1be69df61bc75482c48083e9e Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Tue, 18 Mar 2025 19:10:05 -0300
Subject: [PATCH 5/7] fix: apply suggestions from code review

Co-authored-by: Marylia Gutierrez <maryliag@gmail.com>
---
 .../docs/languages/python/instrumentation.md  | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index 987504a7cb36..59c7f4b0112f 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -40,17 +40,17 @@ provider = TracerProvider()
 processor = BatchSpanProcessor(ConsoleSpanExporter())
 provider.add_span_processor(processor)
 
-# Define o provedor de rastreador global padrão
+# Define o provedor global padrão de rastreador
 trace.set_tracer_provider(provider)
 
-# Cria um rastreador a partir do provedor de rastreador global
+# Cria um rastreador a partir do provedor global de rastreador
 tracer = trace.get_tracer("meu.rastreador.nome")
 ```
 
 ### Criando Trechos {#creating-spans}
 
-Para criar um [trecho](/docs/concepts/signals/traces/#spans), geralmente você
-pretende iniciá-lo como o trecho atual.
+Para criar um [trecho](/docs/concepts/signals/traces/#spans), normalmente você
+vai querer que seja iniciado como o trecho atual.
 
 ```python
 def fazer_trabalho():
@@ -75,7 +75,7 @@ def fazer_trabalho():
     with tracer.start_as_current_span("pai") as parent:
         # faça algum trabalho que 'pai' rastreia
         print("fazendo algum trabalho...")
-        # Crie um trecho aninhado para rastrear trabalho aninhado
+        # Crie um trecho aninhado para rastrear o trabalho aninhado
         with tracer.start_as_current_span("filho") as child:
             # faça algum trabalho que 'filho' rastreia
             print("fazendo algum trabalho aninhado...")
@@ -103,7 +103,7 @@ O uso do decorador é equivalente a criar o trecho dentro de `fazer_trabalho()`
 finalizá-lo quando `fazer_trabalho()` for concluído.
 
 Para usar o decorador, você deve ter uma instância de `tracer` disponível
-globalmente para a declarar sua função.
+globalmente para a declaração da sua função.
 
 ### Obter o Trecho Atual {#get-the-current-span}
 
@@ -128,16 +128,16 @@ from opentelemetry import trace
 
 current_span = trace.get_current_span()
 
-current_span.set_attribute("valor.operacao", 1)
-current_span.set_attribute("nome.operacao", "Dizendo olá!")
-current_span.set_attribute("outras-coisas.operacao", [1, 2, 3])
+current_span.set_attribute("operacao.valor", 1)
+current_span.set_attribute("operacao.nome", "Dizendo olá!")
+current_span.set_attribute("operacao.outras-coisas", [1, 2, 3])
 ```
 
 ### Adicionar Atributos Semânticos {#add-semantic-attributes}
 
 Os [Atributos Semânticos](/docs/specs/semconv/general/trace/) são
 [Atributos](/docs/concepts/signals/traces/#attributes) predeterminados, que são
-nomenclatura bastante conhecidas para tipos comuns de dados. Usar Atributos
+nomenclaturas bastante conhecidas para tipos comuns de dados. Usar Atributos
 Semânticos permite que você normalize esse tipo de informação em seus sistemas.
 
 Para usar Atributos Semânticos em Python, certifique-se de ter o pacote de
@@ -182,7 +182,7 @@ current_span.add_event("Consegui!")
 ### Adicionando Links {#adding-links}
 
 Um [trecho](/docs/concepts/signals/traces/#spans) pode ser criado com zero ou
-mais [links de trecho](/docs/concepts/signals/traces/#span-links) que o ligam
+mais [links de trecho](/docs/concepts/signals/traces/#span-links) que o vinculam
 causalmente a outro trecho. Um link precisa de um contexto de trecho para ser
 criado.
 
@@ -249,7 +249,7 @@ Por padrão, o OpenTelemetry Python usará os seguintes formatos de propagação
 Se você precisar alterar os padrões, pode fazê-lo por meio de variáveis de
 ambiente ou no código:
 
-#### Usando Variáveis de Ambiente
+#### Usando Variáveis de Ambiente {#using-environment-variables}
 
 Você pode definir a variável de ambiente `OTEL_PROPAGATORS` com uma lista
 separada por vírgulas. Os valores aceitos são:
@@ -312,14 +312,14 @@ from opentelemetry.sdk.metrics.export import (
 metric_reader = PeriodicExportingMetricReader(ConsoleMetricExporter())
 provider = MeterProvider(metric_readers=[metric_reader])
 
-# Define o provedor de medidor global padrão
+# Define o provedor global padrão de medidor
 metrics.set_meter_provider(provider)
 
-# Cria um medidor a partir do provedor de medidor global
+# Cria um medidor a partir do provedor global de medidor
 meter = metrics.get_meter("meu.medidor.nome")
 ```
 
-### Criando e Usando Instrumentos Síncronos
+### Criando e Usando Instrumentos Síncronos {#creating-and-using-synchronous-instruments}
 
 Os
 [instrumentos síncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
@@ -346,14 +346,14 @@ como um atributo.
 ```python
 def fazer_trabalho(item_trabalho):
     # conta o trabalho sendo feito
-    work_counter.add(1, {"tipo.trabalho": item_trabalho.tipo_trabalho})
+    work_counter.add(1, {"trabalho.tipo": item_trabalho.tipo_trabalho})
     print("fazendo algum trabalho...")
 ```
 
 ### Criando e Usando Instrumentos Assíncronos {#creating-and-using-asynchronous-instruments}
 
 [Instrumentos assíncronos](/docs/specs/otel/metrics/api/#synchronous-and-asynchronous-instruments)
-fornece ao usuário uma maneira de registrar funções de _callback_, que são
+fornecem ao usuário uma maneira de registrar funções de _callback_, que são
 invocadas sob demanda para fazer medições. Isso é útil para medir periodicamente
 um valor que não pode ser instrumentado diretamente. Os instrumentos assíncronos
 são criados com zero ou mais callbacks que serão invocados durante a coleta de
@@ -362,7 +362,7 @@ métricas. Cada callback aceita opções do SDK e retorna suas observações.
 Este exemplo usa um instrumento
 [Gauge Assíncrono](/docs/specs/otel/metrics/api/#asynchronous-gauge) para
 relatar a versão de configuração atual fornecida por um servidor de
-configuração, raspando um endpoint HTTP. Primeiro, escreva um callback para
+configuração, por meio da extração de um endpoint HTTP. Primeiro, escreva um callback para
 fazer observações:
 
 ```python
@@ -382,7 +382,7 @@ def raspar_versoes_configuracao(options: CallbackOptions) -> Iterable[Observatio
 
 Observe que o OpenTelemetry passará opções para seu callback contendo um
 timeout. Os callbacks devem respeitar esse timeout para evitar bloqueios
-indefinidos. Finalmente, crie o instrumento com o callback para registrá-lo:
+indefinidamente. Por fim, crie o instrumento com o callback para registrá-lo:
 
 ```python
 meter.create_observable_gauge(

From 167523a5b34963c01a4489c521bdc85c2311c13d Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Tue, 18 Mar 2025 19:10:53 -0300
Subject: [PATCH 6/7] fix: apply suggestions from code review

Co-authored-by: Marylia Gutierrez <maryliag@gmail.com>
---
 content/pt/docs/languages/python/instrumentation.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index 59c7f4b0112f..bbb962fbb529 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -335,7 +335,7 @@ de trabalho concluídos:
 
 ```python
 work_counter = meter.create_counter(
-    "contador.trabalho", unit="1", description="Conta a quantidade de trabalho feito"
+    "trabalho.contador", unit="1", description="Conta a quantidade de trabalho feito"
 )
 ```
 

From 7e5db3bf429c575d31671fdea8e46d8ecad93bcf Mon Sep 17 00:00:00 2001
From: Ezzio Moreira <enzziom@gmail.com>
Date: Tue, 18 Mar 2025 19:14:45 -0300
Subject: [PATCH 7/7] fix: lint text

---
 content/pt/docs/languages/python/instrumentation.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/pt/docs/languages/python/instrumentation.md b/content/pt/docs/languages/python/instrumentation.md
index bbb962fbb529..315fb168dfcd 100644
--- a/content/pt/docs/languages/python/instrumentation.md
+++ b/content/pt/docs/languages/python/instrumentation.md
@@ -362,8 +362,8 @@ métricas. Cada callback aceita opções do SDK e retorna suas observações.
 Este exemplo usa um instrumento
 [Gauge Assíncrono](/docs/specs/otel/metrics/api/#asynchronous-gauge) para
 relatar a versão de configuração atual fornecida por um servidor de
-configuração, por meio da extração de um endpoint HTTP. Primeiro, escreva um callback para
-fazer observações:
+configuração, por meio da extração de um endpoint HTTP. Primeiro, escreva um
+callback para fazer observações:
 
 ```python
 from typing import Iterable