aws-lambda-middleware

This Golang package provides helpers to construct AWS Lambda middlewares. It works very similarly to HTTP Middlewares you would find on your favourite HTTP server library.

Features

Only use the AWS Lambda SDK interfaces, no reflection, no type casting
Composable, you can compose Middlewares together into a Middleware Chain

Usage

go get -u github.com/easyCZ/aws-lambda-middleware

Full example available in ./middleware_example_test.go.

import (
    "context"
    "log"
    
    "github.com/easyCZ/aws-lambda-middleware"
    
    "github.com/aws/aws-lambda-go/lambda"
    "github.com/aws/aws-lambda-go/lambdacontext"
)

type HandlerPayload struct {
    Value string `json:"value"`
}


func ExampleMiddleware() {
	logger := log.Default()
	myLambdaHandler := func(ctx context.Context, payload HandlerPayload) error {
		logger.Printf("Handling lambda invocation for payload: %v\n", payload)

		return nil
	}

	handler := lambda.NewHandler(myLambdaHandler)
	handler = lambdamiddleware.Chain(handler, []lambdamiddleware.Middleware{
		LoggingMiddleware(logger),
		ContextExtendMiddleware,
	}...)

	// start your lambda
	lambda.StartHandler(handler)
}

// LoggingMiddleware is a constructor, it allows us to inject dependencies into this middleware.
func LoggingMiddleware(logger *log.Logger) lambdamiddleware.Middleware {
	// We return a Middleware which has access to our logger in a closure
	return func(next lambda.Handler) lambda.Handler {

		// Middleware must return a handler. We use the HandlerFunc helper to write a handler as a single function.
		return lambdamiddleware.HandlerFunc(func(ctx context.Context, bytes []byte) ([]byte, error) {
			// Extract invocation information from the context. This is populated from the lambda runtime and the internal lambda.Handler implementation.
			lctx, _ := lambdacontext.FromContext(ctx)

			// Print the request body, and the request ID.
			// You may want to attach this as structured fields to your *smart* logger.
			logger.Printf("Handing lambda invocation. Request ID: %s. Body: %s\n", lctx.AwsRequestID, string(bytes))

			// Trigger the next middleware in the chain. This may be the actual handler, or another Middleware.
			response, err := next.Invoke(ctx, bytes)

			// We have access to the response, we can choose to log it.
			if err != nil {
				logger.Printf("Finished lambda invocation with error: %s. Request ID: %s. Response: %s.", err.Error(), lctx.AwsRequestID, string(response))
			} else {
				logger.Printf("Finished lambda invocation with OK. Request ID: %s. Response: %s.", lctx.AwsRequestID, string(response))
			}

			// We return the response and the error back to the Middleware before us, or to the AWS Runtime.
			return response, err
		})
	}
}

// ContextExtendMiddleware is a middleware which extends the context with a value
// ContextExtendMiddleware is an example where we do not use a constructor to contruct the middleware, instead we implement the Middleware type directly.
func ContextExtendMiddleware(next lambda.Handler) lambda.Handler {
	// We return a HandlerFunc to get access to the request context.
	return lambdamiddleware.HandlerFunc(func(ctx context.Context, bytes []byte) ([]byte, error) {
		// Attach a custom value to the context.
		ctx = context.WithValue(ctx, "my_key", "my_value")

		// Directly invoke the next handler, without capturing the response and error - we do not need them in this case.
		return next.Invoke(ctx, bytes)
	})
}

Contributions

Contributions welcome. Please raise a Pull Request.