Go-Code debuggen: Vom Anfänger zum Profi an einem Abend

Warum Ihr Go-Code abstürzt und wie Sie das ohne Kopfschmerzen beheben

Sie haben Ihrer Meinung nach perfekten Go-Code geschrieben. Die Kompilierung war erfolgreich, die Tests sind grün... aber in der Produktion fliegt alles in die Luft. Kommt Ihnen bekannt vor? Willkommen in der realen Entwicklungswelt, wo Bugs keine Anfängerfehler sind, sondern Teil des beruflichen Wachstums. Heute analysieren wir das Debuggen von Go-Code so, dass Sie Fehler nicht nur finden, sondern deren Auftreten bereits in der Schreibphase verhindern.

Go ist eine Sprache, die dem Entwickler leistungsstarke Debugging-Werkzeuge direkt "out of the box" bietet. Aber viele verwenden nur fmt.Println und wundern sich aufrichtig, warum sich ihre Goroutinen wie Katzen auf einem heißen Blechdach verhalten. Lassen Sie uns das ein für alle Mal beheben.

Technik Nr. 1: Cleveres Printen – wenn log.Fatal nicht nötig ist

Ja, ich weiß, was Sie sagen werden: "Warum sollte ich Delve brauchen, wenn ich eine Variable ausgeben kann?" Und in 80% der Fälle haben Sie recht. Aber das Problem liegt nicht in fmt.Println, sondern darin, wie Sie es verwenden.

Von Println zu strukturiertem Logging wechseln

Anstatt Dutzende von Prints zu setzen, verwenden Sie das Paket log oder slog (verfügbar ab Go 1.21):

package main\n\nimport (\n    "log/slog"\n    "os"\n)\n\nfunc main() {\n    logger := slog.New(slog.NewTextHandler(os.Stdout, nil))\n    \n    // Statt fmt.Println("Fehler:", err)\n    if err := doSomething(); err != nil {\n        logger.Error("Operation fehlgeschlagen", \n            "error", err,\n            "module", "data_processor",\n            "attempt", 3,\n        )\n    }\n}\n

Dieser Ansatz liefert Ihnen strukturierte Logs, die sich leicht parsen, filtern und analysieren lassen. In der Produktion bewahrt Sie das vor nächtlichen Anrufen.

Lifehack: Bedingte Kompilierung für Debug-Logs

Um die Produktion nicht zu überladen, verwenden Sie build tags:

//go:build debug\n\npackage main\n\nvar debug = true\n

//go:build !debug\n\npackage main\n\nvar debug = false\n

Starten Sie mit dem Flag -tags debug – Sie erhalten detaillierte Logs. Ohne Flag – saubere Produktion.

Technik Nr. 2: Delve – Ihr persönlicher Detektiv für Go

Wenn Print-Debuggen das Fahrrad ist, dann ist Delve das Tesla. Dieser Debugger wurde speziell für Go entwickelt und versteht Goroutinen, Interfaces und sogar Generics. Die Installation ist einfach:

go install github.com/go-delve/delve/cmd/dlv@latest\n

Haltepunkte, die denken können

Delve erlaubt nicht nur einfache Breakpoints, sondern auch bedingte Haltepunkte:

(dlv) break main.go:25 if userID == 42\n(dlv) continue\n

Der Debugger stoppt nur, wenn userID gleich 42 ist. Stellen Sie sich vor, wie viel Zeit das beim Debuggen von Schleifen spart.

Goroutinen untersuchen

Das Schlimmste in Go sind Deadlocks und Race Conditions. Delve zeigt alle aktiven Goroutinen an:

(dlv) goroutines\n  Goroutine 1 - User: ./main.go:10 main.main (0x109a5b6)\n  Goroutine 2 - User: ./main.go:15 main.worker (0x109a6c8)\n* Goroutine 3 - User: ./main.go:22 main.worker (0x109a6c8)\n

Der Stern zeigt die aktuelle Goroutine an. Wechseln Sie zwischen ihnen:

(dlv) goroutine 2\n(dlv) stack\n

Arbeit mit dem Speicher: Einblick ins Innere

Der Befehl locals zeigt alle lokalen Variablen an, und print gibt deren Werte mit Typen aus:

(dlv) locals\ndata = []int len: 100000, cap: 100000\nresult = map[string]int ["error": 5, "success": 99995]\n(dlv) print data[0:5]\n[]int len: 5, cap: 100000, [42, 17, 89, 3, 256]\n

Technik Nr. 3: Profiling mit pprof – Engpässe finden

Ihr Code funktioniert, aber langsam? pprof ist der integrierte Profiler von Go. Er zeigt, wo das Programm "lahmt" und wo es Speicher frisst.

HTTP-Endpoint hinzufügen