[pt] Translate multiple pages on /pt/docs/languages/go

content/pt/docs/languages/go/exporters.md

@@ -0,0 +1,266 @@
+---
+title: Exporters
+aliases: [exporting_data]
+weight: 50
+default_lang_commit: 5e2a0b43c1f9f42824a024206e797cf7041ed9db
+# prettier-ignore
+cSpell:ignore: otlplog otlploggrpc otlploghttp otlpmetric otlpmetricgrpc otlpmetrichttp otlptrace otlptracegrpc otlptracehttp promhttp stdoutlog stdouttrace
+---
+
+{{% docs/languages/exporters/intro go %}}
+
+## Console
+
+O exportador do console é útil para tarefas de desenvolvimento e depuração, e é
+o mais simples de configurar.
+
+### Rastros no Console {#console-traces}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/stdout/stdouttrace`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/stdout/stdouttrace)
+possui uma implementação do Exporter de Rastros para o console.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+func newExporter() (trace.SpanExporter, error) {
+	return stdouttrace.New()
+}
+```
+
+### Métricas no Console {#console-metrics}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/stdout/stdoutmetric`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/stdout/stdoutmetric)
+possui uma implementação do Exporter de Métricas para o console.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric"
+	"go.opentelemetry.io/otel/sdk/metric"
+)
+
+func newExporter() (metric.Exporter, error) {
+	return stdoutmetric.New()
+}
+```
+
+### Logs no Console (Experimental) {#console-logs}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/stdout/stdoutlog`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/stdout/stdoutlog)
+possui uma implementação do Exporter de Logs para o console.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+	"go.opentelemetry.io/otel/exporters/stdout/stdoutlog"
+	"go.opentelemetry.io/otel/sdk/log"
+)
+
+func newExporter() (log.Exporter, error) {
+	return stdoutlog.New()
+}
+```
+
+## OTLP
+
+Para enviar dados de rastreamento para um endpoint OTLP (como o
+[collector](/docs/collector) ou Jaeger >= v1.35.0), você precisará configurar um
+Exporter OTLP que envie os dados para o seu endpoint.
+
+### Rastros OTLP via HTTP {#otlp-traces-over-http}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp)
+possui uma implementação do Exporter de Rastros OTLP utilizando o protocolo HTTP
+com payloads binários protobuf.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+func newExporter(ctx context.Context) (trace.SpanExporter, error) {
+	return otlptracehttp.New(ctx)
+}
+```
+
+### Rastros OTLP via gRPC {#otlp-traces-over-grpc}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc)
+possui uma implementação do Exporter de Rastros OTLP utilizando o protocolo
+gRPC.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+func newExporter(ctx context.Context) (trace.SpanExporter, error) {
+	return otlptracegrpc.New(ctx)
+}
+```
+
+### Jaeger
+
+Para testar o exportador OTLP, a partir da versão v1.35.0 você pode executar o
+[Jaeger](https://www.jaegertracing.io/) como um endpoint OTLP e visualizar os
+rastros em um contêiner Docker:
+
+```shell
+docker run -d --name jaeger \
+  -e COLLECTOR_OTLP_ENABLED=true \
+  -p 16686:16686 \
+  -p 4317:4317 \
+  -p 4318:4318 \
+  jaegertracing/all-in-one:latest
+```
+
+### Métricas OTLP via HTTP {#otlp-metrics-over-http}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp)
+possui uma implementação do Exporter de Métricas OTLP utilizando o protocolo
+HTTP com payloads binários protobuf.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
+	"go.opentelemetry.io/otel/sdk/metric"
+)
+
+func newExporter(ctx context.Context) (metric.Exporter, error) {
+	return otlpmetrichttp.New(ctx)
+}
+```
+
+### Métricas OTLP via gRPC {#otlp-metrics-over-grpc}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc)
+possui uma implementação do Exporter de Métricas OTLP utilizando o protocolo
+gRPC.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
+	"go.opentelemetry.io/otel/sdk/metric"
+)
+
+func newExporter(ctx context.Context) (metric.Exporter, error) {
+	return otlpmetricgrpc.New(ctx)
+}
+```
+
+## Prometheus (Experimental)
+
+O Exporter do Prometheus é utilizado para reportar métricas através do
+_scraping_ realizado pelo Prometheus em um endpoint HTTP.
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/prometheus`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/prometheus)
+possui uma implementação do Exporter de Métricas do Prometheus.
+
+Por exemplo, aqui está como é possível criar um Exporter (que também é um leitor
+de métricas) com as configurações padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/prometheus"
+	"go.opentelemetry.io/otel/sdk/metric"
+)
+
+func newExporter(ctx context.Context) (metric.Reader, error) {
+	// prometheus.DefaultRegisterer é utilizado por padrão, de modo que
+	// as métricas fiquem disponíveis via promhttp.Handler.
+	return prometheus.New()
+}
+```
+
+Para saber mais sobre como usar o Exporter do Prometheus, veja o
+[exemplo do prometheus](https://github.com/open-telemetry/opentelemetry-go-contrib/tree/main/examples/prometheus)
+
+### Logs OTLP via HTTP (Experimental) {#otlp-logs-over-http-experimental}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp)
+possui uma implementação do Exporter de Logs OTLP utilizando o protocolo HTTP
+com payloads binários protobuf.
+
+contains an implementation of OTLP logs exporter using HTTP with binary protobuf
+payloads.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+  "context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
+	"go.opentelemetry.io/otel/sdk/log"
+)
+
+func newExporter(ctx context.Context) (log.Exporter, error) {
+	return otlploghttp.New(ctx)
+}
+```
+
+### Logs OTLP via gRPC (Experimental) {#otlp-logs-over-grpc-experimental}
+
+O pacote
+[`go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc`](https://pkg.go.dev/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc)
+possui uma implementação do Exporter de Logs OTLP utilizando o protocolo gRPC.
+
+Por exemplo, aqui está como é possível criar um Exporter com as configurações
+padrão:
+
+```go
+import (
+	"context"
+
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+	"go.opentelemetry.io/otel/sdk/log"
+)
+
+func newExporter(ctx context.Context) (log.Exporter, error) {
+	return otlploggrpc.New(ctx)
+}
+```

content/pt/docs/languages/go/libraries.md

@@ -0,0 +1,57 @@
+---
+title: Utilizando bibliotecas de instrumentação
+linkTitle: Bibliotecas
+aliases:
+  - /docs/languages/go/using_instrumentation_libraries
+  - /docs/languages/go/automatic_instrumentation
+weight: 40
+default_lang_commit: 825010e3cfece195ae4dfd019eff080ef8eb6365
+---
+
+{{% docs/languages/libraries-intro "go" %}}
+
+## Utilizando bibliotecas de instrumentação {#use-instrumentation-libraries}
+
+Caso uma biblioteca não venha com o OpenTelemetry, você pode utilizar uma
+[biblioteca de instrumentação](/docs/specs/otel/glossary/#instrumentation-library)
+para gerar dados de telemetria para uma biblioteca ou framework.
+
+Por exemplo, a
+[biblioteca de instrumentação para `net/http`](https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp)
+cria automaticamente [trechos](/docs/concepts/signals/traces/#spans) e
+[métricas](/docs/concepts/signals/metrics/) com base nas requisições HTTP.
+
+## Configuração {#setup}
+
+Cada biblioteca de instrumentação é um pacote. Em geral, isso significa que você
+precisa usar `go get` para obter o pacote apropriado. Por exemplo, para obter as
+bibliotecas de instrumentação mantidas no
+[repositório Contrib](https://github.com/open-telemetry/opentelemetry-go-contrib),
+execute o seguinte comando:
+
+```sh
+go get go.opentelemetry.io/contrib/instrumentation/{caminho-de-importacao}/otel{nome-do-pacote}
+```
+
+Em seguida, configure o seu código com base no que a biblioteca requer para ser
+ativada.
+
+Em [Primeiros Passos](../getting-started/) fornecemos um exemplo mostrando como
+configurar a instrumentação para um servidor `net/http`.
+
+## Pacotes disponíveis {#available-packages}
+
+Uma lista completa de bibliotecas de instrumentação disponíveis pode ser
+encontrada no
+[registro do OpenTelemetry](/ecosystem/registry/?language=go&component=instrumentation).
+
+## Próximos passos {#next-steps}
+
+As bibliotecas de instrumentação podem gerar dados de telemetria para
+requisições HTTP de entrada e saída, mas não instrumentam sua aplicação
+completamente.
+
+Enriqueça seus dados de telemetria realizando uma
+[instrumentação personalizada](../instrumentation/) em seu código. Isso
+complementa a telemetria da biblioteca padrão e pode oferecer dados mais
+profundos sobre sua aplicação em execução.

content/pt/docs/languages/go/registry.md

@@ -0,0 +1,10 @@
+---
+title: Registro
+description:
+  Bibliotecas de instrumentação, Exporters e outros componentes úteis para o
+  OpenTelemetry Go
+redirect: /ecosystem/registry/?language=go
+_build: { render: link }
+weight: 300
+default_lang_commit: 1e0c316e3bdac625edc51f0a5037bff6e4611b65
+---

content/pt/docs/languages/go/resources.md

@@ -0,0 +1,57 @@
+---
+title: Recursos
+weight: 70
+cSpell:ignore: sdktrace thirdparty
+default_lang_commit: 12f31f62fcc466532513f6ebccb060c9ea5b9fe4
+---
+
+{{% docs/languages/resources-intro %}}
+
+Recursos devem ser adicionados a um `TracerProvider`, `MeterProvider` e
+`LoggerProvider` durante a sua inicialização, e são criados de maneira
+semelhante aos atributos:
+
+```go
+res := resource.NewWithAttributes(
+    semconv.SchemaURL,
+    semconv.ServiceNameKey.String("meuServico"),
+    semconv.ServiceVersionKey.String("1.0.0"),
+    semconv.ServiceInstanceIDKey.String("abcdef12345"),
+)
+
+provider := sdktrace.NewTracerProvider(
+    ...
+    sdktrace.WithResource(res),
+)
+```
+
+Observe o uso do pacote `semconv` para fornecer
+[nomes convencionais](/docs/concepts/semantic-conventions/) para os atributos do
+recurso. Isso ajuda a garantir que os consumidores da telemetria produzida
+utilizando as convenções semânticas possam identificar facilmente os atributos
+relevantes e entender seu significado.
+
+Os recursos também podem ser detectados automaticamente por meio das
+implementações de `resource.Detector`. Esses `Detector`s podem descobrir
+informações sobre o processo em execução, o sistema operacional em que ele está
+sendo executado, o provedor de nuvem que hospeda a instância do sistema
+operacional ou qualquer número de outros atributos de recurso.
+
+```go
+res, err := resource.New(
+	context.Background(),
+	resource.WithFromEnv(),      // Descobre e fornece atributos das variáveis de ambiente OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME.
+	resource.WithTelemetrySDK(), // Descobre e fornece informações sobre o SDK do OpenTelemetry que está sendo utilizado.
+	resource.WithProcess(),      // Descobre e fornece informações do processo.
+	resource.WithOS(),           // Descobre e fornece informações do Sistema Operacional.
+	resource.WithContainer(),    // Descobre e fornece informações do contêiner.
+	resource.WithHost(),         // Descobre e fornece informações da hospedagem.
+	resource.WithAttributes(attribute.String("foo", "bar")), // Adicionar atributos de recurso personalizados.
+	// resource.WithDetectors(thirdparty.Detector{}), // Inclua a sua própria implementação externa do Detector.
+)
+if errors.Is(err, resource.ErrPartialResource) || errors.Is(err, resource.ErrSchemaURLConflict) {
+	log.Println(err) // Registre problemas não-fatais.
+} else if err != nil {
+	log.Fatalln(err) // O erro pode ser fatal.
+}
+```