Zum Hauptinhalt springen
Gorilla Mux ist ein beliebter Request-Router und -Dispatcher für die Programmiersprache Go.
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.

​
Einrichtung

Um Ihre Gorilla-Mux-Anwendung zu instrumentieren, müssen Sie das offizielle OpenTelemetry-Instrumentierungspaket importieren: 
import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
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 ausführlicher beschrieben. otelmux.Middleware() zu Ihrem App-Router hinzuzufügen, ist alles, was Sie benötigen, um alle Ihre Requests instrumentiert zu bekommen. 
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
	// ...
}

​
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: 
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...
}