Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

4.0 KB
Raw Blame
package middleware

import (
	"context"
	"encoding/json"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/SigNoz/signoz/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestRecovery(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		name            string
		handler         http.HandlerFunc
		wantStatus      int
		wantLog         bool
		wantMessage     string
		wantErrorStatus bool
	}{
		{
			name: "PanicWithString",
			handler: func(w http.ResponseWriter, r *http.Request) {
				panic("something went wrong")
			},
			wantStatus:      http.StatusInternalServerError,
			wantLog:         true,
			wantMessage:     "something went wrong",
			wantErrorStatus: true,
		},
		{
			name: "PanicWithError",
			handler: func(w http.ResponseWriter, r *http.Request) {
				panic(errors.New(errors.TypeInternal, errors.CodeInternal, "db connection failed"))
			},
			wantStatus:      http.StatusInternalServerError,
			wantLog:         true,
			wantMessage:     "db connection failed",
			wantErrorStatus: true,
		},
		{
			name: "PanicWithInteger",
			handler: func(w http.ResponseWriter, r *http.Request) {
				panic(42)
			},
			wantStatus:      http.StatusInternalServerError,
			wantLog:         true,
			wantMessage:     "42",
			wantErrorStatus: true,
		},
		{
			name: "PanicWithDivisionByZero",
			handler: func(w http.ResponseWriter, r *http.Request) {
				divisor := 0
				_ = 1 / divisor
			},
			wantStatus:      http.StatusInternalServerError,
			wantLog:         true,
			wantMessage:     "runtime error: integer divide by zero",
			wantErrorStatus: true,
		},
		{
			name: "NoPanic",
			handler: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
			},
			wantStatus: http.StatusOK,
			wantLog:    false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			var records []slog.Record
			logger := slog.New(newRecordCollector(&records))

			m := NewRecovery(logger)
			handler := m.Wrap(http.HandlerFunc(tc.handler))

			rr := httptest.NewRecorder()
			req := httptest.NewRequest(http.MethodGet, "/", nil)
			handler.ServeHTTP(rr, req)

			assert.Equal(t, tc.wantStatus, rr.Code)

			if !tc.wantLog {
				assert.Empty(t, records)
				return
			}

			require.Len(t, records, 1)

			err := extractException(t, records[0])
			require.NotNil(t, err)

			typ, _, message, _, _, _ := errors.Unwrapb(err)
			assert.Equal(t, errors.TypeFatal, typ)
			assert.Equal(t, tc.wantMessage, message)

			type stacktracer interface {
				Stacktrace() string
			}
			st, ok := err.(stacktracer)
			require.True(t, ok, "error should implement stacktracer")
			assert.NotEmpty(t, st.Stacktrace())

			if tc.wantErrorStatus {
				var body map[string]any
				require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &body))
				assert.Equal(t, "error", body["status"])
			}
		})
	}
}

// extractException finds the "exception" attr in a log record and returns the error.
func extractException(t *testing.T, record slog.Record) error {
	t.Helper()
	var found error
	record.Attrs(func(a slog.Attr) bool {
		if a.Key == "exception" {
			if err, ok := a.Value.Any().(error); ok {
				found = err
				return false
			}
		}
		return true
	})
	return found
}

// recordCollector is an slog.Handler that collects records for assertion.
type recordCollector struct {
	records *[]slog.Record
	attrs   []slog.Attr
}

func newRecordCollector(records *[]slog.Record) *recordCollector {
	return &recordCollector{records: records}
}

func (h *recordCollector) Enabled(_ context.Context, _ slog.Level) bool { return true }

func (h *recordCollector) Handle(_ context.Context, record slog.Record) error {
	for _, a := range h.attrs {
		record.AddAttrs(a)
	}
	*h.records = append(*h.records, record)
	return nil
}

func (h *recordCollector) WithAttrs(attrs []slog.Attr) slog.Handler {
	return &recordCollector{records: h.records, attrs: append(h.attrs, attrs...)}
}

func (h *recordCollector) WithGroup(_ string) slog.Handler { return h }