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

# Gorilla-Mux-Instrumentierung

[Gorilla Mux](https://github.com/gorilla/mux) ist ein beliebter Request-Router und -Dispatcher für die Programmiersprache Go.

<Tip>
  Dieses Projekt wurde im Dezember 2022 als veraltet markiert und wird nicht mehr weiterentwickelt.
  Wir wissen jedoch, dass es ein beliebtes Werkzeug in der Go-Community ist und
  es einige Zeit dauern wird, bis Nutzer ihre Anwendungen auf ein neues Werkzeug migriert haben. Deshalb
  bieten wir Unterstützung für Gorilla-Mux-Anwendungen an, damit Sie wertvolle Informationen
  aus Ihren Diensten erhalten, bis Sie einen geeigneten Ersatz gefunden haben.
</Tip>

## Einrichtung

Um Ihre Gorilla-Mux-Anwendung zu instrumentieren, müssen Sie das offizielle OpenTelemetry-Instrumentierungspaket importieren:

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

Die Gorilla-Mux-Instrumentierung ist als Router-Middleware verpackt. Wie Sie im folgenden Beispiel sehen, wird die Tracer-Initialisierung vor allem anderen aufgerufen, wie im Abschnitt [Go-Konfiguration](/go/configuration) ausführlicher beschrieben. `otelmux.Middleware()` zu Ihrem App-Router hinzuzufügen, ist alles, was Sie benötigen, um alle Ihre Requests instrumentiert zu bekommen.

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

## Request-Parameter melden

Standardmäßig meldet die Gorilla-Instrumentierung keine eingehenden Request-Parameter, wie Query-Strings und JSON-Body-Inhalte.

Um diese Werte an AppSignal zu melden, fügen Sie Ihrem Gorilla-Stack eine Middleware wie folgt hinzu:

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