refactor: simplify example code and integration test

Author: kinbiko

internal/myapp/cmd/app.go

@@ -7,30 +7,23 @@ import (
 	"github.com/kinbiko/rogerr/internal/myapp/pkg/service"
 )
 
-// App represents the main application
 type App struct {
 	name    string
 	service *service.ProcessingService
 	handler *handler.RequestHandler
 }
 
-// NewApp creates a new application instance
-func NewApp(name string) *App {
+func NewApp() *App {
 	svc := service.NewProcessingService()
-	hdl := handler.NewRequestHandler(svc)
-	
-	return &App{
-		name:    name,
-		service: svc,
-		handler: hdl,
-	}
+	handler := handler.NewRequestHandler(svc)
+	return &App{name: "demo-app", service: svc, handler: handler}
 }
 
 // Execute runs the application with the given arguments
 func (app *App) Execute(ctx context.Context, args []string) error {
 	if len(args) == 0 {
 		return app.handler.HandleRequest(ctx, "default")
 	}
-	
+
 	return app.handler.HandleRequest(ctx, args[0])
-}
+}

internal/myapp/integration_test.go

@@ -9,160 +9,42 @@ import (
 
 func TestStacktraceIntegration(t *testing.T) {
 	err := run([]string{"testdata"})
-	
 	if err == nil {
 		t.Fatal("expected error from run")
 	}
-	
-	// Use ErrorHandler to extract stacktrace
-	handler := rogerr.NewErrorHandler()
-	frames := handler.Stacktrace(err)
-	if len(frames) == 0 {
-		t.Fatal("expected stacktrace frames")
-	}
-	
-	// Log all frames for debugging
-	t.Log("Captured stacktrace frames:")
-	for i, frame := range frames {
-		t.Logf("  [%d] %s (%s:%d) InApp=%v", i, frame.Function, frame.File, frame.Line, frame.InApp)
-	}
-	
-	// Define expected frames in reverse order (closest to error first)
-	expectedFrames := []struct {
-		functionPattern string
-		filePattern     string
-		inApp           bool
-		description     string
-	}{
-		{
-			functionPattern: "executeBusinessLogic.func1",
-			filePattern:     "/internal/myapp/pkg/service/processing.go",
-			inApp:           true,
-			description:     "anonymous function in service package",
-		},
-		{
-			functionPattern: "executeBusinessLogic",
-			filePattern:     "/internal/myapp/pkg/service/processing.go",
-			inApp:           true,
-			description:     "method on ProcessingService",
-		},
-		{
-			functionPattern: "ProcessData",
-			filePattern:     "/internal/myapp/pkg/service/processing.go",
-			inApp:           true,
-			description:     "method on ProcessingService",
-		},
-		{
-			functionPattern: "processRequest.func1",
-			filePattern:     "/internal/myapp/pkg/handler/request.go",
-			inApp:           true,
-			description:     "anonymous function in handler package",
-		},
-		{
-			functionPattern: "processRequest",
-			filePattern:     "/internal/myapp/pkg/handler/request.go",
-			inApp:           true,
-			description:     "method on RequestHandler",
-		},
-		{
-			functionPattern: "HandleRequest",
-			filePattern:     "/internal/myapp/pkg/handler/request.go",
-			inApp:           true,
-			description:     "method on RequestHandler",
-		},
-		{
-			functionPattern: "Execute",
-			filePattern:     "/internal/myapp/cmd/app.go",
-			inApp:           true,
-			description:     "method on App struct",
-		},
-		{
-			functionPattern: "run",
-			filePattern:     "/internal/myapp/main.go",
-			inApp:           true,
-			description:     "main package function",
-		},
-	}
-	
-	// Validate that myapp frames are marked as InApp=true
-	myappFrameCount := 0
+
+	frames := rogerr.NewErrorHandler().Stacktrace(err)
+	var myappFrames, mylibFrames, rogerrFrames int
+
 	for _, frame := range frames {
-		if strings.Contains(frame.File, "/internal/myapp/") {
-			myappFrameCount++
+		if frame.File == "" || frame.Function == "" || frame.Line <= 0 {
+			t.Errorf("Invalid frame: %+v", frame)
+		}
+
+		switch {
+		case strings.Contains(frame.File, "/internal/myapp/"):
+			myappFrames++
 			if !frame.InApp {
-				t.Errorf("Frame from myapp should be InApp=true: %s (%s:%d)", 
-					frame.Function, frame.File, frame.Line)
+				t.Errorf("myapp frame should be InApp=true: %s", frame.Function)
 			}
-		}
-	}
-	
-	if myappFrameCount == 0 {
-		t.Error("expected to find frames from myapp module")
-	}
-	
-	// Validate that mylib frames are marked as InApp=false
-	mylibFrameCount := 0
-	for _, frame := range frames {
-		if strings.Contains(frame.File, "/internal/mylib/") {
-			mylibFrameCount++
+		case strings.Contains(frame.File, "/internal/mylib/"):
+			mylibFrames++
 			if frame.InApp {
-				t.Errorf("Frame from mylib should be InApp=false: %s (%s:%d)", 
-					frame.Function, frame.File, frame.Line)
+				t.Errorf("mylib frame should be InApp=false: %s", frame.Function)
 			}
+		case strings.HasPrefix(frame.Function, "github.com/kinbiko/rogerr."):
+			rogerrFrames++
+			t.Errorf("Found rogerr main package frame: %s", frame.Function)
 		}
 	}
-	
-	if mylibFrameCount == 0 {
-		t.Error("expected to find frames from mylib module")
-	}
-	
-	// Validate specific function patterns exist (only for myapp frames)
-	foundFunctions := make(map[string]bool)
-	for _, frame := range frames {
-		// Skip testing framework frames and mylib frames for our validation
-		if strings.Contains(frame.Function, "testing.") || 
-		   strings.Contains(frame.Function, "runtime.") ||
-		   strings.Contains(frame.Function, "github.com/kinbiko/rogerr/internal/mylib") {
-			continue
-		}
-		
-		for _, expected := range expectedFrames {
-			if strings.Contains(frame.Function, expected.functionPattern) {
-				foundFunctions[expected.functionPattern] = true
-				
-				// Validate file path
-				if !strings.Contains(frame.File, expected.filePattern) {
-					t.Errorf("Frame %s should be in file containing %s, got %s", 
-						frame.Function, expected.filePattern, frame.File)
-				}
-				
-				// Validate InApp status
-				if frame.InApp != expected.inApp {
-					t.Errorf("Frame %s should have InApp=%v, got %v", 
-						frame.Function, expected.inApp, frame.InApp)
-				}
-				
-				// Validate line number is reasonable
-				if frame.Line <= 0 {
-					t.Errorf("Frame %s should have positive line number, got %d", 
-						frame.Function, frame.Line)
-				}
-			}
-		}
+
+	if myappFrames != 9 {
+		t.Errorf("expected 9 frames from myapp module, got %d", myappFrames)
 	}
-	
-	// Check that we found all expected function patterns
-	for _, expected := range expectedFrames {
-		if !foundFunctions[expected.functionPattern] {
-			t.Errorf("Expected to find function containing '%s' (%s) in stacktrace", 
-				expected.functionPattern, expected.description)
-		}
+	if mylibFrames != 5 {
+		t.Errorf("expected 5 frames from mylib module, got %d", mylibFrames)
 	}
-	
-	// Validate that no rogerr main package frames are present
-	for _, frame := range frames {
-		if strings.HasPrefix(frame.Function, "github.com/kinbiko/rogerr.") {
-			t.Errorf("Found rogerr main package frame in stacktrace: %s", frame.Function)
-		}
+	if rogerrFrames != 0 {
+		t.Errorf("expected 0 frames from rogerr module, got %d", rogerrFrames)
 	}
-}
+}

internal/myapp/main.go

@@ -10,52 +10,49 @@ import (
 )
 
 func main() {
-	// Configure slog for JSON output
-	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	}))
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
 	slog.SetDefault(logger)
 
 	args := os.Args[1:] // Skip program name
 	if len(args) == 0 {
-		args = []string{"demo-data"} // Default argument for demo
+		args = []string{"demo-data"}
 	}
 
 	err := run(args)
-	if err != nil {
-		// Extract stacktrace using ErrorHandler
-		handler := rogerr.NewErrorHandler()
-		frames := handler.Stacktrace(err)
-
-		// Convert frames to OTEL logging data model format
-		frameData := make([]map[string]interface{}, len(frames))
-		for i, frame := range frames {
-			frameData[i] = map[string]interface{}{
-				"code.function": frame.Function,
-				"code.filepath": frame.File,
-				"code.lineno":   frame.Line,
-				"code.namespace": func() string {
-					if frame.InApp {
-						return "application"
-					}
-					return "dependency"
-				}(),
-			}
-		}
+	if err == nil {
+		return
+	}
 
-		// Log using OTEL logging data model semantic conventions
-		slog.Error("Exception occurred",
-			slog.String("exception.type", "ApplicationError"),
-			slog.String("exception.message", err.Error()),
-			slog.Any("exception.stacktrace", frameData),
-			slog.String("service.name", "demo-app"),
-			slog.String("service.version", "1.0.0"),
-		)
+	frames := rogerr.NewErrorHandler().Stacktrace(err)
+
+	// Convert frames to OTEL logging data model format
+	frameData := make([]map[string]interface{}, len(frames))
+	for i, frame := range frames {
+		frameData[i] = map[string]interface{}{
+			"code.function": frame.Function,
+			"code.filepath": frame.File,
+			"code.lineno":   frame.Line,
+			"code.namespace": func() string {
+				if frame.InApp {
+					return "application"
+				}
+				return "dependency"
+			}(),
+		}
 	}
+
+	// Log using OTEL logging data model semantic conventions
+	slog.Error("Exception occurred",
+		slog.String("exception.type", "ApplicationError"),
+		slog.String("exception.message", err.Error()),
+		slog.Any("exception.stacktrace", frameData),
+		slog.String("service.name", "demo-app"),
+		slog.String("service.version", "1.0.0"),
+	)
 }
 
 func run(args []string) error {
 	ctx := context.Background()
-	app := cmd.NewApp("demo-app")
+	app := cmd.NewApp()
 	return app.Execute(ctx, args)
 }

internal/myapp/pkg/handler/request.go

@@ -6,29 +6,22 @@ import (
 	"github.com/kinbiko/rogerr/internal/myapp/pkg/service"
 )
 
-// RequestHandler handles incoming requests
 type RequestHandler struct {
 	service *service.ProcessingService
 }
 
-// NewRequestHandler creates a new request handler
 func NewRequestHandler(svc *service.ProcessingService) *RequestHandler {
-	return &RequestHandler{
-		service: svc,
-	}
+	return &RequestHandler{service: svc}
 }
 
-// HandleRequest processes a request with the given input
 func (h *RequestHandler) HandleRequest(ctx context.Context, input string) error {
 	return h.processRequest(ctx, input)
 }
 
-// processRequest is an internal method that validates and processes the request
 func (h *RequestHandler) processRequest(ctx context.Context, input string) error {
-	// Add validation layer
 	validateFunc := func() error {
 		return h.service.ProcessData(ctx, input)
 	}
-	
+
 	return validateFunc()
-}
+}

internal/myapp/pkg/service/processing.go

@@ -6,29 +6,24 @@ import (
 	"github.com/kinbiko/rogerr/internal/mylib"
 )
 
-// ProcessingService handles business logic
 type ProcessingService struct {
 	name string
 }
 
-// NewProcessingService creates a new processing service
 func NewProcessingService() *ProcessingService {
 	return &ProcessingService{
 		name: "data-processor",
 	}
 }
 
-// ProcessData processes the given data through the business logic layer
 func (s *ProcessingService) ProcessData(ctx context.Context, data string) error {
 	return s.executeBusinessLogic(ctx, data)
 }
 
-// executeBusinessLogic runs the core business logic
 func (s *ProcessingService) executeBusinessLogic(ctx context.Context, data string) error {
-	// Call library function through service layer
 	callLibrary := func() error {
 		return mylib.ComplexOperation(ctx, data)
 	}
-	
+
 	return callLibrary()
-}
+}

internal/mylib/errors.go

@@ -28,12 +28,12 @@ func (es *ErrorService) CreateError(ctx context.Context, msg string) error {
 // ProcessDataWithError is a package-level function that creates an error
 func ProcessDataWithError(ctx context.Context, data string) error {
 	service := NewErrorService()
-	
+
 	// Call through anonymous function to add another stack frame
 	processFunc := func() error {
 		return service.CreateError(ctx, "failed to process data: "+data)
 	}
-	
+
 	return processFunc()
 }
 
@@ -45,4 +45,4 @@ func ComplexOperation(ctx context.Context, input string) error {
 // intermediateFunction is a helper function in the call chain
 func intermediateFunction(ctx context.Context, input string) error {
 	return ProcessDataWithError(ctx, input)
-}
+}