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

# Installation d'OpenTelemetry Go

Veuillez suivre d'abord le [guide d'installation](/guides/new-application) lorsque vous ajoutez une nouvelle application à AppSignal.

Ensuite, assurez-vous d'[installer le collecteur AppSignal](/collector/installation) avant de continuer.

## Configurer OpenTelemetry dans votre application

OpenTelemetry doit être initialisé avant le démarrage de votre application, pour garantir que toutes les données de télémétrie sont envoyées via l'exportateur vers AppSignal. Par exemple, dans une application web, OpenTelemetry doit être initialisé avant que les routes ne soient chargées et que le serveur ne démarre.

Créez une fonction `initOpenTelemetry()` comme celle de l'exemple ci-dessous et ajoutez-la au fichier principal de votre application.

Assurez-vous de mettre à jour les valeurs ci-dessous avec le nom de votre application AppSignal, l'environnement et la clé push API, et de remplacer le point d'accès de l'exportateur par l'adresse de votre collecteur AppSignal si nécessaire.

<CodeGroup>
  ```go Go theme={null}
  package main

  import (
  	// Import these standard libraries used in the OpenTelemetry configuration
  	"context"
  	"log"
  	"os"
  	"os/exec"
  	"strings"

  	// Import these OpenTelemetry libraries
  	"go.opentelemetry.io/otel"
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
  	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
  	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
  	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
  	"go.opentelemetry.io/otel/log/global"
  	"go.opentelemetry.io/otel/propagation"
  	sdklog "go.opentelemetry.io/otel/sdk/log"
  	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
  	sdkresource "go.opentelemetry.io/otel/sdk/resource"
  	sdktrace "go.opentelemetry.io/otel/sdk/trace"
  )

  func initOpenTelemetry() func() {
  	// Replace these values with your AppSignal application name, environment
  	// and push API key. These are used by the resource attributes configuration below.
  	name := "My app"
  	push_api_key := "0000-0000-0000-0000"
  	environment := "development"

  	// Set the name of the service that is being monitored. A common choice is the
  	// name of the framework used. This is used to group traces and metrics in AppSignal.
  	service_name := "My service name"

  	// Replace `localhost:8099` with the address of your AppSignal collector
  	// if it's running on another host.
  	endpoint := "localhost:8099"

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

  	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))
  	}

  	resource, err := sdkresource.Merge(
  		sdkresource.Default(),
  		sdkresource.NewSchemaless(
  			attribute.String("appsignal.config.name", name),
  			attribute.String("appsignal.config.environment", environment),
  			attribute.String("appsignal.config.push_api_key", push_api_key),
  			attribute.String("appsignal.config.revision", revision),
  			attribute.String("appsignal.config.language_integration", "go"),
  			attribute.String("appsignal.config.app_path", os.Getenv("PWD")),
  			attribute.String("service.name", service_name),
  			attribute.String("host.name", hostname),
  		),
  	)
  	if err != nil {
  		log.Fatalf("Error creating OTLP resource: %v", err)
  	}

  	// Tracing
  	traceClient := otlptracehttp.NewClient(
  		otlptracehttp.WithInsecure(), // Remove if the collector is accessible via HTTPS
  		otlptracehttp.WithEndpoint(endpoint),
  	)

  	traceExporter, err := otlptrace.New(context.Background(), traceClient)
  	if err != nil {
  		log.Fatalf("Error creating OTLP trace exporter: %v", err)
  	}

  	tracerProvider := sdktrace.NewTracerProvider(
  		sdktrace.WithBatcher(traceExporter),
  		sdktrace.WithResource(resource),
  	)

  	otel.SetTracerProvider(tracerProvider)
  	otel.SetTextMapPropagator(
  		propagation.NewCompositeTextMapPropagator(
  			propagation.TraceContext{},
  			propagation.Baggage{},
  		),
  	)

  	// Metrics
  	metricExporter, err := otlpmetrichttp.New(
  		context.Background(),
  		otlpmetrichttp.WithInsecure(), // Remove if the collector is accessible via HTTPS
  		otlpmetrichttp.WithEndpoint(endpoint),
  	)
  	if err != nil {
  		log.Fatalf("creating OTLP metric exporter: %v", err)
  	}

  	meterProvider := sdkmetric.NewMeterProvider(
  		sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExporter)),
  		sdkmetric.WithResource(resource),
  	)
  	otel.SetMeterProvider(meterProvider)

  	// Logs
  	logExporter, err := otlploghttp.New(
  		context.Background(),
  		otlploghttp.WithInsecure(), // Remove if the collector is accessible via HTTPS
  		otlploghttp.WithEndpoint(endpoint),
  	)
  	if err != nil {
  		log.Fatalf("creating OTLP log exporter: %v", err)
  	}

  	loggerProvider := sdklog.NewLoggerProvider(
  		sdklog.WithResource(resource),
  		sdklog.WithProcessor(
  			sdklog.NewBatchProcessor(logExporter),
  		),
  	)
  	global.SetLoggerProvider(loggerProvider)

  	// Cleanup
  	return func() {
  		ctx := context.Background()
  		if err := tracerProvider.Shutdown(ctx); err != nil {
  			log.Println("Error shutting down tracer provider:", err)
  		}
  		if err := meterProvider.Shutdown(ctx); err != nil {
  			log.Println("Error shutting down meter provider:", err)
  		}
  		if err := loggerProvider.Shutdown(ctx); err != nil {
  			log.Println("Error shutting down logger provider:", err)
  		}
  	}
  }

  func main() {
  	cleanup := initOpenTelemetry()
  	defer cleanup()

  	// ... your application's initialization code
  }
  ```
</CodeGroup>

*Si votre collecteur est accessible via HTTPS, supprimez les trois lignes contenant l'appel de méthode `WithInsecure()` dans l'exemple de configuration.*

Pour installer les bibliothèques OpenTelemetry importées dans l'exemple ci-dessus, exécutez cette commande.

<CodeGroup>
  ```sh Shell theme={null}
  go mod tidy
  ```
</CodeGroup>

## Configurer les paquets d'instrumentation OpenTelemetry

La stack OpenTelemetry n'émettra aucune donnée par elle-même. Pour instrumenter votre application, installez et configurez les paquets d'instrumentation pour les bibliothèques et frameworks utilisés par votre application. Vous pouvez [trouver les paquets d'instrumentation OpenTelemetry dans le registre OpenTelemetry](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=go\&flag=all).

Pour certaines instrumentations OpenTelemetry populaires, vous pouvez trouver des instructions de configuration spécifiques sur ces pages :

* [Gin-gonic](/go/instrumentations/gin-gonic)
* [Gorilla mux](/go/instrumentations/gorilla-mux)
* [MongoDB](/go/instrumentations/mongo)
* [Redis](/go/instrumentations/redis)
* [SQL](/go/instrumentations/sql)

## Tester l'application !

Maintenant que tous les composants sont connectés, démarrez votre application et testez si vous voyez des données arriver dans AppSignal. Vérifiez les pages ["Errors > Issue list"](https://appsignal.com/redirect-to/app?to=exceptions) et ["Performance > Traces"](https://appsignal.com/redirect-to/app?to=performance/traces) en particulier.

Si après avoir suivi nos instructions d'installation, vous ne voyez toujours pas de données dans AppSignal, [faites-le nous savoir](mailto:support@appsignal.com?subject=OpenTelemetry%20beta%20issue) et nous vous aiderons à finaliser votre installation OpenTelemetry !

## Ajouter des paquets d'instrumentation

L'étape suivante consiste à instrumenter des paquets Go comme Gin-gonic, Gorilla, etc. Cela fournira beaucoup plus de données pour vraiment plonger dans les performances de vos applications.

Les étapes pour chaque paquet sont généralement les suivantes :

* Installez le paquet d'instrumentation OpenTelemetry pour la bibliothèque que vous souhaitez instrumenter.
* Suivez les instructions d'installation pour le paquet d'instrumentation.

Pour plus d'informations sur l'installation et la configuration par bibliothèque, veuillez consulter la [section des instrumentations Go][instrumentations].

[Go language]: https://go.dev/

[OpenTelemetry]: https://opentelemetry.io/

[instrumentations]: /go/instrumentations.html