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

# Instrumentation Gorilla Mux

[Gorilla Mux](https://github.com/gorilla/mux) est un routeur et dispatcher de requêtes populaire pour le langage Go.

<Tip>
  Ce projet a été déprécié en décembre 2022 et n'est plus pris en charge,
  cependant, nous savons que c'est un outil populaire dans la communauté Go, et
  il faudra du temps aux utilisateurs pour migrer leurs applications vers de nouveaux outils. C'est pourquoi
  nous fournissons le support pour les applications Gorilla Mux, afin que vous obteniez des informations précieuses
  de vos services jusqu'à ce que vous trouviez un remplaçant approprié.
</Tip>

## Configuration

Pour instrumenter votre application Gorilla Mux, vous devrez importer le paquet d'instrumentation officiel OpenTelemetry :

<CodeGroup>
  ```go Go theme={null}
  import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
  ```
</CodeGroup>

L'instrumentation Gorilla Mux est packagée comme un middleware de routeur. Comme vous pouvez le voir dans l'exemple ci-dessous, l'initialisation du tracer est appelée avant tout autre chose, comme décrit plus en détail dans la section [Configuration Go](/go/configuration). Ajouter `otelmux.Middleware()` au routeur de votre application est tout ce dont vous avez besoin pour instrumenter toutes vos requêtes.

<CodeGroup>
  ```go Go theme={null}
  func main() {
  	cleanup := initOpenTelemetry()
  	defer cleanup()

  	router := mux.NewRouter().StrictSlash(true)
  	// This middleware must be added before any middlewares or routes
  	router.Use(otelmux.Middleware("your-app-name"))
  	// Your routes, app's logic, and server start up
  	// ...
  }
  ```
</CodeGroup>

## Reporter les paramètres de requête

Par défaut, l'instrumentation Gorilla ne reporte aucun paramètre de requête entrant, comme les chaînes de requête et le contenu du corps JSON.

Pour reporter ces valeurs à AppSignal, ajoutez un middleware à votre stack Gorilla comme suit :

<CodeGroup>
  ```go Go theme={null}
  import (
  	"bytes"
  	"encoding/json"
  	"io/ioutil"
  	"net/http"
  	"net/url"

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

  func recordParameters(next http.Handler) http.Handler {
  	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		span := trace.SpanFromContext(r.Context())

  		// Query parameters
  		requestQueryParameters := r.URL.Query()
  		attributeQueryParameters := make(map[string]any)
  		for k, v := range requestQueryParameters {
  			attributeQueryParameters[k] = v
  		}

  		if len(attributeQueryParameters) > 0 {
  			serializedQueryParams, err := json.Marshal(attributeQueryParameters)
  			if err == nil {
  				span.SetAttributes(attribute.String("appsignal.request.query_parameters", string(serializedQueryParams)))
  			}
  		}

  		// Request body payload
  		var serializedBodyPayload string
  		var payload map[string]interface{}
  		requestBodyPayload, err := ioutil.ReadAll(r.Body)
  		if err != nil {
  			next.ServeHTTP(w, r)
  			return
  		}
  		r.Body = ioutil.NopCloser(bytes.NewBuffer(requestBodyPayload))
  		contentType := r.Header.Get("Content-Type")
  		if contentType == "application/json" {
  			serializedBodyPayload = string(requestBodyPayload)
  		} else if contentType == "application/x-www-form-urlencoded" {
  			// Parse form-urlencoded body
  			values, err := url.ParseQuery(string(requestBodyPayload))
  			if err != nil {
  				next.ServeHTTP(w, r)
  				return
  			}

  			// Convert form values to a JSON-compatible map
  			payload = make(map[string]interface{})
  			for key, val := range values {
  				if len(val) == 1 {
  					payload[key] = val[0]
  				} else {
  					payload[key] = val
  				}
  			}
  			json, _ := json.Marshal(payload)
  			serializedBodyPayload = string(json)
  		} else {
  			next.ServeHTTP(w, r)
  			return
  		}
  		if len(serializedBodyPayload) > 0 {
  			span.SetAttributes(attribute.String("appsignal.request.payload", serializedBodyPayload))
  		}
  		next.ServeHTTP(w, r)
  	})
  }

  func main() {
  	// Init OpenTelemetry
  	cleanup := initOpenTelemetry()
  	defer cleanup()

  	router := mux.NewRouter().StrictSlash(true)
  	router.Use(otelmux.Middleware("opentelemetry-go-gorillamux"))
  	// After the OpenTelemetry middleware, but before your other middlewares:
  	router.Use(recordParameters)
  	// Other middlewares and router handlers go here...
  }
  ```
</CodeGroup>