feat: add metrics system, move webhook feature to dedicated module (#372)

pkg/gotenberg/flags.go

@@ -25,6 +25,17 @@ func (f *ParsedFlags) MustString(name string) string {
 	return val
 }
 
+// MustDeprecatedString returns the string value of a deprecated flag if it was
+// explicitly set or the string value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustString(deprecated)
+	}
+
+	return f.MustString(newName)
+}
+
 // MustStringSlice returns the string slice value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustStringSlice(name string) []string {
@@ -36,6 +47,17 @@ func (f *ParsedFlags) MustStringSlice(name string) []string {
 	return val
 }
 
+// MustDeprecatedStringSlice returns the string slice value of a deprecated
+// flag if it was explicitly set or the string slice value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedStringSlice(deprecated string, newName string) []string {
+	if f.Changed(deprecated) {
+		return f.MustStringSlice(deprecated)
+	}
+
+	return f.MustStringSlice(newName)
+}
+
 // MustBool returns the boolean value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustBool(name string) bool {
@@ -47,6 +69,17 @@ func (f *ParsedFlags) MustBool(name string) bool {
 	return val
 }
 
+// MustDeprecatedBool returns the boolean value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedBool(deprecated string, newName string) bool {
+	if f.Changed(deprecated) {
+		return f.MustBool(deprecated)
+	}
+
+	return f.MustBool(newName)
+}
+
 // MustInt returns the int value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustInt(name string) int {
@@ -58,6 +91,17 @@ func (f *ParsedFlags) MustInt(name string) int {
 	return val
 }
 
+// MustDeprecatedInt returns the int value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt(deprecated string, newName string) int {
+	if f.Changed(deprecated) {
+		return f.MustInt(deprecated)
+	}
+
+	return f.MustInt(newName)
+}
+
 // MustFloat64 returns the float value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustFloat64(name string) float64 {
@@ -69,6 +113,17 @@ func (f *ParsedFlags) MustFloat64(name string) float64 {
 	return val
 }
 
+// MustDeprecatedFloat64 returns the float value of a deprecated flag if it was
+// explicitly set or the float value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedFloat64(deprecated string, newName string) float64 {
+	if f.Changed(deprecated) {
+		return f.MustFloat64(deprecated)
+	}
+
+	return f.MustFloat64(newName)
+}
+
 // MustDuration returns the time.Duration value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustDuration(name string) time.Duration {
@@ -80,6 +135,17 @@ func (f *ParsedFlags) MustDuration(name string) time.Duration {
 	return val
 }
 
+// MustDeprecatedDuration returns the time.Duration value of a deprecated flag
+// if it was explicitly set or the time.Duration value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string) time.Duration {
+	if f.Changed(deprecated) {
+		return f.MustDuration(deprecated)
+	}
+
+	return f.MustDuration(newName)
+}
+
 // MustHumanReadableBytesString returns the human-readable bytes string of a
 // flag given by name.
 // It panics if an error occurs.
@@ -97,6 +163,18 @@ func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
 	return val
 }
 
+// MustDeprecatedHumanReadableBytesString returns the human-readable bytes
+// string of a deprecated flag if it was explicitly set or the human-readable
+// bytes string of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytesString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustHumanReadableBytesString(deprecated)
+	}
+
+	return f.MustHumanReadableBytesString(newName)
+}
+
 // MustRegexp returns the regular expression of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
@@ -107,3 +185,14 @@ func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
 
 	return regexp.MustCompile(val)
 }
+
+// MustDeprecatedRegexp returns the regular expression of a deprecated flag if
+// it was explicitly set or the regular expression of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedRegexp(deprecated string, newName string) *regexp.Regexp {
+	if f.Changed(deprecated) {
+		return f.MustRegexp(deprecated)
+	}
+
+	return f.MustRegexp(newName)
+}

pkg/gotenberg/flags_test.go

@@ -1,6 +1,8 @@
 package gotenberg
 
 import (
+	"reflect"
+	"regexp"
 	"testing"
 	"time"
 
@@ -52,6 +54,42 @@ func TestParsedFlags_MustString(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedString(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: "foo",
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: "bar",
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: "foo",
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedString("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustStringSlice(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.StringSlice("foo", make([]string, 0), "")
@@ -97,6 +135,42 @@ func TestParsedFlags_MustStringSlice(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedStringSlice(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue []string
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: []string{"foo"},
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: []string{"bar"},
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: []string{"foo"},
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.StringSlice("foo", make([]string, 0), "")
+		fs.StringSlice("bar", make([]string, 0), "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedStringSlice("foo", "bar")
+		if !reflect.DeepEqual(actual, tc.expectValue) {
+			t.Errorf("test %d: expected %+v but got %+v", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustBool(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Bool("foo", false, "")
@@ -142,6 +216,42 @@ func TestParsedFlags_MustBool(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedBool(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue bool
+	}{
+		{
+			rawFlags:    []string{"--foo=true"},
+			expectValue: true,
+		},
+		{
+			rawFlags:    []string{"--bar=false"},
+			expectValue: false,
+		},
+		{
+			rawFlags:    []string{"--foo=true", "--bar=false"},
+			expectValue: true,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Bool("foo", false, "")
+		fs.Bool("bar", true, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedBool("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %v but got %v", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustInt(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Int("foo", 0, "")
@@ -187,6 +297,42 @@ func TestParsedFlags_MustInt(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedInt(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue int
+	}{
+		{
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Int("foo", 0, "")
+		fs.Int("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedInt("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %d but got %d", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustFloat64(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Float64("foo", 1.0, "")
@@ -232,6 +378,42 @@ func TestParsedFlags_MustFloat64(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedFloat64(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue float64
+	}{
+		{
+			rawFlags:    []string{"--foo=1.0"},
+			expectValue: 1.0,
+		},
+		{
+			rawFlags:    []string{"--bar=2.0"},
+			expectValue: 2.0,
+		},
+		{
+			rawFlags:    []string{"--foo=1.0", "--bar=2.0"},
+			expectValue: 1.0,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Float64("foo", 0, "")
+		fs.Float64("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedFloat64("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %f but got %f", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustDuration(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Duration("foo", time.Duration(1)*time.Second, "")
@@ -277,6 +459,42 @@ func TestParsedFlags_MustDuration(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue time.Duration
+	}{
+		{
+			rawFlags:    []string{"--foo=1s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+		{
+			rawFlags:    []string{"--bar=2s"},
+			expectValue: time.Duration(2) * time.Second,
+		},
+		{
+			rawFlags:    []string{"--foo=1s", "--bar=2s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Duration("foo", 0, "")
+		fs.Duration("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedDuration("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "1MB", "")
@@ -327,6 +545,42 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			rawFlags:    []string{"--foo=1MB"},
+			expectValue: "1MB",
+		},
+		{
+			rawFlags:    []string{"--bar=2MB"},
+			expectValue: "2MB",
+		},
+		{
+			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
+			expectValue: "1MB",
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustRegexp(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "", "")
@@ -376,3 +630,39 @@ func TestParsedFlags_MustRegexp(t *testing.T) {
 		}()
 	}
 }
+
+func TestParsedFlags_MustDeprecatedRegexp(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue *regexp.Regexp
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: regexp.MustCompile("bar"),
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedRegexp("foo", "bar")
+		if actual.String() != tc.expectValue.String() {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue.String(), actual.String())
+		}
+	}
+}

pkg/gotenberg/metrics.go

@@ -0,0 +1,26 @@
+package gotenberg
+
+// Metric represents a unitary metric.
+type Metric struct {
+	// Name is the unique identifier.
+	// Required.
+	Name string
+
+	// Description describes the metric.
+	// Optional.
+	Description string
+
+	// Read returns the current value.
+	// Required.
+	Read func() float64
+}
+
+// MetricsProvider is a module interface which provides a list of Metric.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.MetricsProvider))
+//		metrics, _  := provider.(gotenberg.MetricsProvider).Metrics()
+//	}
+type MetricsProvider interface {
+	Metrics() ([]Metric, error)
+}

pkg/modules/api/api.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -26,8 +25,8 @@ func init() {
 	gotenberg.MustRegisterModule(API{})
 }
 
-// API is a module which provides an HTTP server. Other modules may add
-// "multipart/form-data" routes, middlewares or health checks.
+// API is a module which provides an HTTP server. Other modules may add routes,
+// middlewares or health checks.
 type API struct {
 	port                      int
 	readTimeout               time.Duration
@@ -36,38 +35,41 @@ type API struct {
 	rootPath                  string
 	traceHeader               string
 	disableHealthCheckLogging bool
-	webhookAllowList          *regexp.Regexp
-	webhookDenyList           *regexp.Regexp
-	webhookErrorAllowList     *regexp.Regexp
-	webhookErrorDenyList      *regexp.Regexp
-	webhookMaxRetry           int
-	webhookRetryMinWait       time.Duration
-	webhookRetryMaxWait       time.Duration
-	disableWebhook            bool
 
-	multipartFormDataRoutes []MultipartFormDataRoute
-	externalMiddlewares     []Middleware
-	healthChecks            []health.CheckerOption
-	logger                  *zap.Logger
-	srv                     *echo.Echo
+	routes              []Route
+	externalMiddlewares []Middleware
+	healthChecks        []health.CheckerOption
+	gcGraceDuration     time.Duration
+	logger              *zap.Logger
+	srv                 *echo.Echo
 }
 
-// MultipartFormDataRouter is a module interface which adds
-// "multipart/form-data" routes to the API.
-type MultipartFormDataRouter interface {
-	Routes() ([]MultipartFormDataRoute, error)
+// Router is a module interface which adds routes to the API.
+type Router interface {
+	Routes() ([]Route, error)
 }
 
-// MultipartFormDataRoute represents a "multipart/form-data" route. All routes
-// uses the HTTP POST method.
-type MultipartFormDataRoute struct {
+// Route represents a route from a Router.
+type Route struct {
+	// Method is the HTTP method of the route (i.e., GET, POST, etc.).
+	// Required.
+	Method string
+
 	// Path is the sub path of the route. Must start with a slash.
 	// Required.
 	Path string
 
+	// IsMultipart tells if the route is "multipart/form-data".
+	// Optional.
+	IsMultipart bool
+
+	// DisableLogging disables the logging for this route.
+	// Optional.
+	DisableLogging bool
+
 	// Handler is the function which handles the request.
 	// Required.
-	Handler func(ctx *Context) error
+	Handler echo.HandlerFunc
 }
 
 // MiddlewareProvider is a module interface which adds middlewares to the API.
@@ -75,8 +77,18 @@ type MiddlewareProvider interface {
 	Middlewares() ([]Middleware, error)
 }
 
+// MiddlewareStack is a type which helps to determine in which stack the
+// middlewares provided by the MiddlewareProvider modules should be located.
+type MiddlewareStack uint32
+
+const (
+	DefaultStack MiddlewareStack = iota
+	PreRouterStack
+	MultipartStack
+)
+
 // MiddlewarePriority is a type which helps to determine the execution order of
-// middlewares provided by the MiddlewareProvider modules.
+// middlewares provided by the MiddlewareProvider modules in a stack.
 type MiddlewarePriority uint32
 
 const (
@@ -113,13 +125,13 @@ const (
 //    }(),
 //  }
 type Middleware struct {
-	// RunBeforeRouter tells if the middleware should run before the router
-	// process an HTTP request.
+	// Stack tells in which stack the middleware should be located.
+	// Default to DefaultStack.
 	// Optional.
-	RunBeforeRouter bool
+	Stack MiddlewareStack
 
 	// Priority tells if the middleware should be positioned high or not in
-	// the middlewares chain.
+	// its stack.
 	// Default to VeryLowPriority.
 	// Optional.
 	Priority MiddlewarePriority
@@ -137,6 +149,12 @@ type HealthChecker interface {
 	Checks() ([]health.CheckerOption, error)
 }
 
+// GarbageCollectorGraceDurationIncrementer is a module interface for
+// increasing the grace duration provided by the API for the garbage collector.
+type GarbageCollectorGraceDurationIncrementer interface {
+	AddGraceDuration() time.Duration
+}
+
 // Descriptor returns an API's module descriptor.
 func (API) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
@@ -151,14 +169,6 @@ func (API) Descriptor() gotenberg.ModuleDescriptor {
 			fs.String("api-root-path", "/", "Set the root path of the API - for service discovery via URL paths")
 			fs.String("api-trace-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
 			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
-			fs.String("api-webhook-allow-list", "", "Set the allowed URLs for the webhook feature using a regular expression")
-			fs.String("api-webhook-deny-list", "", "Set the denied URLs for the webhook feature using a regular expression")
-			fs.String("api-webhook-error-allow-list", "", "Set the allowed URLs in case of an error for the webhook feature using a regular expression")
-			fs.String("api-webhook-error-deny-list", "", "Set the denied URLs in case of an error for the webhook feature using a regular expression")
-			fs.Int("api-webhook-max-retry", 4, "Set the maximum number of retries for the webhook feature")
-			fs.Duration("api-webhook-retry-min-wait", time.Duration(1)*time.Second, "Set the minimum duration to wait before trying to call the webhook again")
-			fs.Duration("api-webhook-retry-max-wait", time.Duration(30)*time.Second, "Set the maximum duration to wait before trying to call the webhook again")
-			fs.Bool("api-disable-webhook", false, "Disable the webhook feature")
 
 			return fs
 		}(),
@@ -176,14 +186,6 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 	a.rootPath = flags.MustString("api-root-path")
 	a.traceHeader = flags.MustString("api-trace-header")
 	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
-	a.webhookAllowList = flags.MustRegexp("api-webhook-allow-list")
-	a.webhookDenyList = flags.MustRegexp("api-webhook-deny-list")
-	a.webhookErrorAllowList = flags.MustRegexp("api-webhook-error-allow-list")
-	a.webhookErrorDenyList = flags.MustRegexp("api-webhook-error-deny-list")
-	a.webhookMaxRetry = flags.MustInt("api-webhook-max-retry")
-	a.webhookRetryMinWait = flags.MustDuration("api-webhook-retry-min-wait")
-	a.webhookRetryMaxWait = flags.MustDuration("api-webhook-retry-max-wait")
-	a.disableWebhook = flags.MustBool("api-disable-webhook")
 
 	// Port from env?
 	portEnvVar := flags.MustString("api-port-from-env")
@@ -207,14 +209,14 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 	}
 
 	// Get routes from modules.
-	mods, err := ctx.Modules(new(MultipartFormDataRouter))
+	mods, err := ctx.Modules(new(Router))
 	if err != nil {
-		return fmt.Errorf("get multipart/form-data routers: %w", err)
+		return fmt.Errorf("get routers: %w", err)
 	}
 
-	routers := make([]MultipartFormDataRouter, len(mods))
+	routers := make([]Router, len(mods))
 	for i, router := range mods {
-		routers[i] = router.(MultipartFormDataRouter)
+		routers[i] = router.(Router)
 	}
 
 	for _, router := range routers {
@@ -223,7 +225,7 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 			return fmt.Errorf("get routes: %w", err)
 		}
 
-		a.multipartFormDataRoutes = append(a.multipartFormDataRoutes, routes...)
+		a.routes = append(a.routes, routes...)
 	}
 
 	// Get middlewares from modules.
@@ -271,6 +273,18 @@ func (a *API) Provision(ctx *gotenberg.Context) error {
 		a.healthChecks = append(a.healthChecks, checks...)
 	}
 
+	// Grace duration.
+	a.gcGraceDuration = a.readTimeout + a.processTimeout + a.writeTimeout
+
+	mods, err = ctx.Modules(new(GarbageCollectorGraceDurationIncrementer))
+	if err != nil {
+		return fmt.Errorf("get garbage collector grace duration increments: %w", err)
+	}
+
+	for _, incrementer := range mods {
+		a.gcGraceDuration += incrementer.(GarbageCollectorGraceDurationIncrementer).AddGraceDuration()
+	}
+
 	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
 	if err != nil {
 		return fmt.Errorf("get logger provider: %w", err)
@@ -318,26 +332,35 @@ func (a API) Validate() error {
 		return err
 	}
 
-	routesMap := make(map[string]MultipartFormDataRoute, len(a.multipartFormDataRoutes))
+	routesMap := make(map[string]string, len(a.routes)+1)
+	routesMap["/health"] = "/health"
 
-	for _, route := range a.multipartFormDataRoutes {
+	for _, route := range a.routes {
 		if route.Path == "" {
 			return errors.New("route with empty path cannot be registered")
 		}
 
 		if !strings.HasPrefix(route.Path, "/") {
-			return fmt.Errorf("route %s does not start with /", route.Path)
+			return fmt.Errorf("route '%s' does not start with /", route.Path)
+		}
+
+		if route.IsMultipart && !strings.HasPrefix(route.Path, "/forms") {
+			return fmt.Errorf("multipart/form-data route '%s' does not start with /forms", route.Path)
+		}
+
+		if route.Method == "" {
+			return fmt.Errorf("route '%s' has an empty method", route.Path)
 		}
 
 		if route.Handler == nil {
-			return fmt.Errorf("route %s has a nil handler", route.Path)
+			return fmt.Errorf("route '%s' has a nil handler", route.Path)
 		}
 
 		if _, ok := routesMap[route.Path]; ok {
-			return fmt.Errorf("route %s is already registered", route.Path)
+			return fmt.Errorf("route '%s' is already registered", route.Path)
 		}
 
-		routesMap[route.Path] = route
+		routesMap[route.Path] = route.Path
 	}
 
 	for _, middleware := range a.externalMiddlewares {
@@ -356,94 +379,83 @@ func (a *API) Start() error {
 	a.srv.HidePort = true
 	a.srv.Server.ReadTimeout = a.readTimeout
 	a.srv.Server.WriteTimeout = a.writeTimeout
-	a.srv.HTTPErrorHandler = httpErrorHandler(a.traceHeader)
+	a.srv.HTTPErrorHandler = httpErrorHandler()
 
+	// Let's prepare the modules' routes.
+	var disableLoggingForPaths []string
+	for i, route := range a.routes {
+		a.routes[i].Path = strings.TrimPrefix(route.Path, "/")
+
+		if route.DisableLogging {
+			disableLoggingForPaths = append(disableLoggingForPaths, strings.TrimPrefix(route.Path, "/"))
+		}
+	}
+
+	// Check if the user wish to add logging entries related to the health
+	// check route.
+	if a.disableHealthCheckLogging {
+		disableLoggingForPaths = append(disableLoggingForPaths, "health")
+	}
+
+	// Add the API middlewares.
 	a.srv.Pre(
 		latencyMiddleware(),
 		rootPathMiddleware(a.rootPath),
 		traceMiddleware(a.traceHeader),
-		loggerMiddleware(a.logger, a.disableHealthCheckLogging),
+		timeoutsMiddleware(a.readTimeout, a.processTimeout, a.writeTimeout),
+		loggerMiddleware(a.logger, disableLoggingForPaths),
 	)
 
+	// Add the modules' middlewares in their respective stacks.
+	var externalMultipartMiddlewares []Middleware
 	for _, externalMiddleware := range a.externalMiddlewares {
-		if externalMiddleware.RunBeforeRouter {
+		switch externalMiddleware.Stack {
+		case PreRouterStack:
 			a.srv.Pre(externalMiddleware.Handler)
-
-			continue
+		case MultipartStack:
+			externalMultipartMiddlewares = append(externalMultipartMiddlewares, externalMiddleware)
+		default:
+			a.srv.Use(externalMiddleware.Handler)
 		}
-
-		a.srv.Use(externalMiddleware.Handler)
 	}
 
 	hardTimeout := a.processTimeout + (time.Duration(5) * time.Second)
 
+	// Add the modules' routes and their specific middlewares.
+	for _, route := range a.routes {
+		var middlewares []echo.MiddlewareFunc
+
+		if route.IsMultipart {
+			middlewares = append(middlewares, contextMiddleware(a.processTimeout))
+
+			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
+				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
+			}
+		}
+
+		middlewares = append(middlewares, hardTimeoutMiddleware(hardTimeout))
+
+		a.srv.Add(
+			route.Method,
+			fmt.Sprintf("%s%s", a.rootPath, route.Path),
+			route.Handler,
+			middlewares...,
+		)
+	}
+
+	// Let's not forget the health check route.
 	a.srv.GET(
-		fmt.Sprintf("%shealth", a.rootPath),
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
 		func() echo.HandlerFunc {
 			checks := append(a.healthChecks, health.WithTimeout(a.processTimeout))
 			checker := health.NewChecker(checks...)
 
 			return echo.WrapHandler(health.NewHandler(checker))
 		}(),
-		timeoutMiddleware(hardTimeout),
+		hardTimeoutMiddleware(hardTimeout),
 	)
 
-	formsGroup := a.srv.Group(
-		fmt.Sprintf("%sforms", a.rootPath),
-		contextMiddleware(
-			contextMiddlewareConfig{
-				traceHeader: a.traceHeader,
-				timeout: struct {
-					process time.Duration
-					write   time.Duration
-				}{
-					process: a.processTimeout,
-					write:   a.writeTimeout,
-				},
-				webhook: struct {
-					allowList      *regexp.Regexp
-					denyList       *regexp.Regexp
-					errorAllowList *regexp.Regexp
-					errorDenyList  *regexp.Regexp
-					maxRetry       int
-					retryMinWait   time.Duration
-					retryMaxWait   time.Duration
-					disable        bool
-				}{
-					allowList:      a.webhookAllowList,
-					denyList:       a.webhookDenyList,
-					errorAllowList: a.webhookErrorAllowList,
-					errorDenyList:  a.webhookErrorDenyList,
-					maxRetry:       a.webhookMaxRetry,
-					retryMinWait:   a.webhookRetryMinWait,
-					retryMaxWait:   a.webhookRetryMaxWait,
-					disable:        a.disableWebhook,
-				},
-			},
-		),
-		timeoutMiddleware(hardTimeout),
-	)
-
-	// Add routes from other modules.
-	for _, route := range a.multipartFormDataRoutes {
-		formsGroup.POST(
-			route.Path,
-			func(route MultipartFormDataRoute) echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-
-					err := route.Handler(ctx)
-					if err != nil {
-						return fmt.Errorf("handle request: %w", err)
-					}
-
-					return nil
-				}
-			}(route),
-		)
-	}
-
-	// As the listen method is blocking, run it in a goroutine.
+	// As the following code is blocking, run it in a goroutine.
 	go func() {
 		server := &http2.Server{}
 		err := a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
@@ -468,18 +480,7 @@ func (a API) Stop(ctx context.Context) error {
 // GraceDuration updates the expiration time of files and directories parsed by
 // the gc.GarbageCollector.
 func (a API) GraceDuration() time.Duration {
-	duration := a.readTimeout + a.processTimeout + a.writeTimeout
-
-	if a.disableWebhook {
-		return duration
-	}
-
-	for i := 0; i < a.webhookMaxRetry; i++ {
-		// Yep... Golang does not allow int * time.Duration.
-		duration += a.webhookRetryMaxWait
-	}
-
-	return duration
+	return a.gcGraceDuration
 }
 
 // Interface guards.

pkg/modules/api/api_test.go

@@ -35,12 +35,12 @@ func (mod ProtoValidator) Validate() error {
 	return mod.validate()
 }
 
-type ProtoMultipartFormDataRouter struct {
+type ProtoRouter struct {
 	ProtoValidator
-	routes func() ([]MultipartFormDataRoute, error)
+	routes func() ([]Route, error)
 }
 
-func (mod ProtoMultipartFormDataRouter) Routes() ([]MultipartFormDataRoute, error) {
+func (mod ProtoRouter) Routes() ([]Route, error) {
 	return mod.routes()
 }
 
@@ -62,6 +62,15 @@ func (mod ProtoHealthChecker) Checks() ([]health.CheckerOption, error) {
 	return mod.checks()
 }
 
+type ProtoGarbageCollectorGraceDurationIncrementer struct {
+	ProtoValidator
+	addGraceDuration func() time.Duration
+}
+
+func (mod ProtoGarbageCollectorGraceDurationIncrementer) AddGraceDuration() time.Duration {
+	return mod.addGraceDuration()
+}
+
 type ProtoLoggerProvider struct {
 	ProtoModule
 	logger func(mod gotenberg.Module) (*zap.Logger, error)
@@ -84,11 +93,12 @@ func TestAPI_Descriptor(t *testing.T) {
 
 func TestAPI_Provision(t *testing.T) {
 	for i, tc := range []struct {
-		ctx               *gotenberg.Context
-		setEnv            func(i int)
-		expectPort        int
-		expectMiddlewares []Middleware
-		expectErr         bool
+		ctx                 *gotenberg.Context
+		setEnv              func(i int)
+		expectPort          int
+		expectMiddlewares   []Middleware
+		expectGraceDuration time.Duration
+		expectErr           bool
 	}{
 		{
 			ctx: func() *gotenberg.Context {
@@ -183,14 +193,14 @@ func TestAPI_Provision(t *testing.T) {
 		},
 		{
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoMultipartFormDataRouter }{}
+				mod := struct{ ProtoRouter }{}
 				mod.descriptor = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
 				}
 				mod.validate = func() error {
 					return errors.New("foo")
 				}
-				mod.routes = func() ([]MultipartFormDataRoute, error) {
+				mod.routes = func() ([]Route, error) {
 					return nil, nil
 				}
 
@@ -255,14 +265,14 @@ func TestAPI_Provision(t *testing.T) {
 		},
 		{
 			ctx: func() *gotenberg.Context {
-				mod := struct{ ProtoMultipartFormDataRouter }{}
+				mod := struct{ ProtoRouter }{}
 				mod.descriptor = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
 				}
 				mod.validate = func() error {
 					return nil
 				}
-				mod.routes = func() ([]MultipartFormDataRoute, error) {
+				mod.routes = func() ([]Route, error) {
 					return nil, errors.New("foo")
 				}
 
@@ -325,6 +335,60 @@ func TestAPI_Provision(t *testing.T) {
 			}(),
 			expectErr: true,
 		},
+
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct {
+					ProtoGarbageCollectorGraceDurationIncrementer
+				}{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return errors.New("foo")
+				}
+				mod.addGraceDuration = func() time.Duration {
+					return 0
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct {
+					ProtoGarbageCollectorGraceDurationIncrementer
+				}{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.addGraceDuration = func() time.Duration {
+					return time.Duration(3) * time.Second
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(API).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectGraceDuration: time.Duration(93) * time.Second,
+			expectErr:           true,
+		},
 		{
 			ctx: func() *gotenberg.Context {
 				return gotenberg.NewContext(
@@ -359,15 +423,15 @@ func TestAPI_Provision(t *testing.T) {
 		},
 		{
 			ctx: func() *gotenberg.Context {
-				mod1 := struct{ ProtoMultipartFormDataRouter }{}
+				mod1 := struct{ ProtoRouter }{}
 				mod1.descriptor = func() gotenberg.ModuleDescriptor {
 					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod1 }}
 				}
 				mod1.validate = func() error {
 					return nil
 				}
-				mod1.routes = func() ([]MultipartFormDataRoute, error) {
-					return []MultipartFormDataRoute{{}}, nil
+				mod1.routes = func() ([]Route, error) {
+					return []Route{{}}, nil
 				}
 
 				mod2 := struct{ ProtoMiddlewareProvider }{}
@@ -455,11 +519,15 @@ func TestAPI_Provision(t *testing.T) {
 		err := mod.Provision(tc.ctx)
 
 		if tc.expectPort != 0 && mod.port != tc.expectPort {
-			t.Errorf("expected port %d but got %d", tc.expectPort, mod.port)
+			t.Errorf("test %d: expected port %d but got %d", i, tc.expectPort, mod.port)
 		}
 
 		if !reflect.DeepEqual(mod.externalMiddlewares, tc.expectMiddlewares) {
-			t.Errorf("expected %+v, but got: %+v", tc.expectMiddlewares, mod.externalMiddlewares)
+			t.Errorf("test %d: expected %+v, but got: %+v", i, tc.expectMiddlewares, mod.externalMiddlewares)
+		}
+
+		if tc.expectGraceDuration != 0 && mod.gcGraceDuration != tc.expectGraceDuration {
+			t.Errorf("test %d: expected gc grace duration '%s' but got '%s'", i, tc.expectGraceDuration, mod.gcGraceDuration)
 		}
 
 		if tc.expectErr && err == nil {
@@ -477,7 +545,7 @@ func TestAPI_Validate(t *testing.T) {
 		port        int
 		rootPath    string
 		traceHeader string
-		routes      []MultipartFormDataRoute
+		routes      []Route
 		middlewares []Middleware
 		expectErr   bool
 	}{
@@ -494,7 +562,7 @@ func TestAPI_Validate(t *testing.T) {
 			port:        10,
 			rootPath:    "/foo/",
 			traceHeader: "foo",
-			routes: []MultipartFormDataRoute{
+			routes: []Route{
 				{
 					Path: "",
 				},
@@ -505,7 +573,7 @@ func TestAPI_Validate(t *testing.T) {
 			port:        10,
 			rootPath:    "/foo/",
 			traceHeader: "foo",
-			routes: []MultipartFormDataRoute{
+			routes: []Route{
 				{
 					Path: "foo",
 				},
@@ -516,9 +584,10 @@ func TestAPI_Validate(t *testing.T) {
 			port:        10,
 			rootPath:    "/foo/",
 			traceHeader: "foo",
-			routes: []MultipartFormDataRoute{
+			routes: []Route{
 				{
-					Path: "/foo",
+					Path:        "/foo",
+					IsMultipart: true,
 				},
 			},
 			expectErr: true,
@@ -527,14 +596,41 @@ func TestAPI_Validate(t *testing.T) {
 			port:        10,
 			rootPath:    "/foo/",
 			traceHeader: "foo",
-			routes: []MultipartFormDataRoute{
+			routes: []Route{
 				{
+					Path:        "/forms/foo",
+					IsMultipart: true,
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:      http.MethodPost,
+					Path:        "/forms/foo",
+					IsMultipart: true,
+				},
+			},
+			expectErr: true,
+		},
+		{
+			port:        10,
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes: []Route{
+				{
+					Method:  http.MethodPost,
 					Path:    "/foo",
-					Handler: func(_ *Context) error { return nil },
+					Handler: func(_ echo.Context) error { return nil },
 				},
 				{
+					Method:  http.MethodPost,
 					Path:    "/foo",
-					Handler: func(_ *Context) error { return nil },
+					Handler: func(_ echo.Context) error { return nil },
 				},
 			},
 			expectErr: true,
@@ -554,10 +650,11 @@ func TestAPI_Validate(t *testing.T) {
 			port:        10,
 			rootPath:    "/foo/",
 			traceHeader: "foo",
-			routes: []MultipartFormDataRoute{
+			routes: []Route{
 				{
+					Method:  http.MethodGet,
 					Path:    "/foo",
-					Handler: func(_ *Context) error { return nil },
+					Handler: func(_ echo.Context) error { return nil },
 				},
 			},
 			middlewares: []Middleware{
@@ -575,11 +672,11 @@ func TestAPI_Validate(t *testing.T) {
 		},
 	} {
 		mod := API{
-			port:                    tc.port,
-			rootPath:                tc.rootPath,
-			traceHeader:             tc.traceHeader,
-			multipartFormDataRoutes: tc.routes,
-			externalMiddlewares:     tc.middlewares,
+			port:                tc.port,
+			rootPath:            tc.rootPath,
+			traceHeader:         tc.traceHeader,
+			routes:              tc.routes,
+			externalMiddlewares: tc.middlewares,
 		}
 
 		err := mod.Validate()
@@ -598,10 +695,15 @@ func TestAPI_Start(t *testing.T) {
 	mod := new(API)
 	mod.port = 3000
 	mod.rootPath = "/"
-	mod.multipartFormDataRoutes = []MultipartFormDataRoute{
+	mod.disableHealthCheckLogging = true
+	mod.routes = []Route{
 		{
-			Path: "/foo",
-			Handler: func(ctx *Context) error {
+			Method:         http.MethodPost,
+			Path:           "/forms/foo",
+			IsMultipart:    true,
+			DisableLogging: true,
+			Handler: func(c echo.Context) error {
+				ctx := c.Get("context").(*Context)
 				ctx.outputPaths = []string{
 					"/tests/test/testdata/api/sample1.txt",
 				}
@@ -610,13 +712,35 @@ func TestAPI_Start(t *testing.T) {
 			},
 		},
 		{
-			Path:    "/bar",
-			Handler: func(_ *Context) error { return errors.New("foo") },
+			Method:      http.MethodPost,
+			Path:        "/forms/bar",
+			IsMultipart: true,
+			Handler:     func(_ echo.Context) error { return errors.New("foo") },
 		},
 	}
 	mod.externalMiddlewares = []Middleware{
 		{
-			RunBeforeRouter: true,
+			Stack: PreRouterStack,
+			Handler: func() echo.MiddlewareFunc {
+				return func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						return next(c)
+					}
+				}
+			}(),
+		},
+		{
+			Stack: MultipartStack,
+			Handler: func() echo.MiddlewareFunc {
+				return func(next echo.HandlerFunc) echo.HandlerFunc {
+					return func(c echo.Context) error {
+						return next(c)
+					}
+				}
+			}(),
+		},
+		{
+			Stack: DefaultStack,
 			Handler: func() echo.MiddlewareFunc {
 				return func(next echo.HandlerFunc) echo.HandlerFunc {
 					return func(c echo.Context) error {
@@ -721,10 +845,11 @@ func TestAPI_StartupMessage(t *testing.T) {
 func TestAPI_Stop(t *testing.T) {
 	mod := API{
 		port: 3000,
-		multipartFormDataRoutes: []MultipartFormDataRoute{
+		routes: []Route{
 			{
+				Method:  http.MethodGet,
 				Path:    "/foo",
-				Handler: func(_ *Context) error { return nil },
+				Handler: func(_ echo.Context) error { return nil },
 			},
 		},
 		logger: zap.NewNop(),
@@ -742,52 +867,35 @@ func TestAPI_Stop(t *testing.T) {
 }
 
 func TestAPI_GraceDuration(t *testing.T) {
-	for i, tc := range []struct {
-		mod    API
-		expect time.Duration
-	}{
-		{
-			mod: API{
-				readTimeout:    time.Duration(1) * time.Second,
-				processTimeout: time.Duration(1) * time.Second,
-				writeTimeout:   time.Duration(1) * time.Second,
-				disableWebhook: true,
-			},
-			expect: time.Duration(3) * time.Second,
-		},
-		{
-			mod: API{
-				readTimeout:         time.Duration(1) * time.Second,
-				processTimeout:      time.Duration(1) * time.Second,
-				writeTimeout:        time.Duration(1) * time.Second,
-				webhookMaxRetry:     5,
-				webhookRetryMaxWait: time.Duration(5) * time.Second,
-			},
-			expect: time.Duration(28) * time.Second,
-		},
-	} {
-		actual := tc.mod.GraceDuration()
+	mod := API{
+		gcGraceDuration: time.Duration(3) * time.Second,
+	}
 
-		if actual != tc.expect {
-			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expect, actual)
-		}
+	expect := time.Duration(3) * time.Second
+	actual := mod.GraceDuration()
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
 	}
 }
 
 // Interface guards.
 var (
-	_ gotenberg.Module         = (*ProtoModule)(nil)
-	_ gotenberg.Validator      = (*ProtoValidator)(nil)
-	_ gotenberg.Module         = (*ProtoValidator)(nil)
-	_ MultipartFormDataRouter  = (*ProtoMultipartFormDataRouter)(nil)
-	_ gotenberg.Module         = (*ProtoMultipartFormDataRouter)(nil)
-	_ gotenberg.Validator      = (*ProtoMultipartFormDataRouter)(nil)
-	_ MiddlewareProvider       = (*ProtoMiddlewareProvider)(nil)
-	_ gotenberg.Module         = (*ProtoMiddlewareProvider)(nil)
-	_ gotenberg.Validator      = (*ProtoMiddlewareProvider)(nil)
-	_ HealthChecker            = (*ProtoHealthChecker)(nil)
-	_ gotenberg.Module         = (*ProtoHealthChecker)(nil)
-	_ gotenberg.Validator      = (*ProtoHealthChecker)(nil)
-	_ gotenberg.LoggerProvider = (*ProtoLoggerProvider)(nil)
-	_ gotenberg.Module         = (*ProtoLoggerProvider)(nil)
+	_ gotenberg.Module                         = (*ProtoModule)(nil)
+	_ gotenberg.Validator                      = (*ProtoValidator)(nil)
+	_ gotenberg.Module                         = (*ProtoValidator)(nil)
+	_ Router                                   = (*ProtoRouter)(nil)
+	_ gotenberg.Module                         = (*ProtoRouter)(nil)
+	_ gotenberg.Validator                      = (*ProtoRouter)(nil)
+	_ MiddlewareProvider                       = (*ProtoMiddlewareProvider)(nil)
+	_ gotenberg.Module                         = (*ProtoMiddlewareProvider)(nil)
+	_ gotenberg.Validator                      = (*ProtoMiddlewareProvider)(nil)
+	_ HealthChecker                            = (*ProtoHealthChecker)(nil)
+	_ gotenberg.Module                         = (*ProtoHealthChecker)(nil)
+	_ gotenberg.Validator                      = (*ProtoHealthChecker)(nil)
+	_ GarbageCollectorGraceDurationIncrementer = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
+	_ gotenberg.Module                         = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
+	_ gotenberg.Validator                      = (*ProtoGarbageCollectorGraceDurationIncrementer)(nil)
+	_ gotenberg.LoggerProvider                 = (*ProtoLoggerProvider)(nil)
+	_ gotenberg.Module                         = (*ProtoLoggerProvider)(nil)
 )

pkg/modules/api/context.go

@@ -227,9 +227,9 @@ func (ctx Context) Log() *zap.Logger {
 	return ctx.logger
 }
 
-// buildOutputFile builds the output file according to the output paths
+// BuildOutputFile builds the output file according to the output paths
 // registered in the context. If many output paths, an archive is created.
-func (ctx Context) buildOutputFile() (string, error) {
+func (ctx Context) BuildOutputFile() (string, error) {
 	if ctx.cancelled {
 		return "", ErrContextAlreadyClosed
 	}
@@ -265,6 +265,18 @@ func (ctx Context) buildOutputFile() (string, error) {
 	return archivePath, nil
 }
 
+// OutputFilename returns the filename based on the given output path or the
+// "Gotenberg-Output-Filename" header's value.
+func (ctx Context) OutputFilename(outputPath string) string {
+	filename := ctx.echoCtx.Request().Header.Get("Gotenberg-Output-Filename")
+
+	if filename == "" {
+		return filepath.Base(outputPath)
+	}
+
+	return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
+}
+
 // MockContext is a helper for tests.
 //
 //  ctx := &api.MockContext{Context: &api.Context{}}
@@ -316,3 +328,19 @@ func (ctx *MockContext) SetCancelled(cancelled bool) {
 func (ctx MockContext) OutputPaths() []string {
 	return ctx.outputPaths
 }
+
+// SetLogger sets the logger.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.SetLogger(zap.NewNop())
+func (ctx *MockContext) SetLogger(logger *zap.Logger) {
+	ctx.logger = logger
+}
+
+// SetEchoContext sets the echo.Context.
+//
+//  ctx := &api.MockContext{Context: &api.Context{}}
+//  ctx.setEchoContext(c)
+func (ctx *MockContext) SetEchoContext(c echo.Context) {
+	ctx.Context.echoCtx = c
+}

pkg/modules/api/context_test.go

@@ -248,7 +248,7 @@ func TestContext_Log(t *testing.T) {
 	}
 }
 
-func TestContext_buildOutputFile(t *testing.T) {
+func TestContext_BuildOutputFile(t *testing.T) {
 	for i, tc := range []struct {
 		ctx       *Context
 		expectErr bool
@@ -285,7 +285,7 @@ func TestContext_buildOutputFile(t *testing.T) {
 		tc.ctx.dirPath = dirPath
 		tc.ctx.logger = zap.NewNop()
 
-		_, err = tc.ctx.buildOutputFile()
+		_, err = tc.ctx.BuildOutputFile()
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -302,6 +302,39 @@ func TestContext_buildOutputFile(t *testing.T) {
 	}
 }
 
+func TestContext_OutputFilename(t *testing.T) {
+	for i, tc := range []struct {
+		ctx                  *Context
+		outputPath           string
+		expectOutputFilename string
+	}{
+		{
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				c.Request().Header.Set("Gotenberg-Output-Filename", "foo")
+
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/bar.txt",
+			expectOutputFilename: "foo.txt",
+		},
+		{
+			ctx: func() *Context {
+				c := echo.New().NewContext(httptest.NewRequest(http.MethodGet, "/foo", nil), nil)
+				return &Context{echoCtx: c}
+			}(),
+			outputPath:           "/foo/foo.txt",
+			expectOutputFilename: "foo.txt",
+		},
+	} {
+		actual := tc.ctx.OutputFilename(tc.outputPath)
+
+		if actual != tc.expectOutputFilename {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectOutputFilename, actual)
+		}
+	}
+}
+
 func TestMockContext_SetDirPath(t *testing.T) {
 	mock := &MockContext{&Context{}}
 	mock.SetDirPath("/foo")
@@ -371,3 +404,29 @@ func TestMockContext_OutputPaths(t *testing.T) {
 		t.Errorf("expected %+v but got: %+v", expect, actual)
 	}
 }
+
+func TestMockContext_SetLogger(t *testing.T) {
+	mock := MockContext{&Context{}}
+
+	expect := zap.NewNop()
+	mock.SetLogger(expect)
+
+	actual := mock.logger
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
+func TestMockContext_SetEchoContext(t *testing.T) {
+	mock := MockContext{&Context{}}
+
+	expect := echo.New().NewContext(nil, nil)
+	mock.SetEchoContext(expect)
+
+	actual := mock.echoCtx
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}

pkg/modules/api/middlewares.go

@@ -1,95 +1,54 @@
 package api
 
 import (
-	"bufio"
-	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 )
 
+// ErrAsyncProcess happens when a handler or middleware handles a request in an
+// asynchronous fashion.
+var ErrAsyncProcess = errors.New("async process")
+
+// ParseError parses an error and returns the corresponding HTTP status and
+// HTTP message.
+func ParseError(err error) (int, string) {
+	echoErr, ok := err.(*echo.HTTPError)
+	if ok {
+		return echoErr.Code, http.StatusText(echoErr.Code)
+	}
+
+	if errors.Is(err, context.DeadlineExceeded) {
+		return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
+	}
+
+	var httpErr HTTPError
+	if errors.As(err, &httpErr) {
+		return httpErr.HTTPError()
+	}
+
+	// Default 500 status code.
+	return http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)
+}
+
 // httpErrorHandler is the centralized HTTP error handler. It parses the error,
-// returns either a response as "text/plain; charset=UTF-8" or, if a webhook
-// client exists in the echo.Context, sends a request to the webhook error URL
-// with a JSON body containing the trace, the status and the error message.
-func httpErrorHandler(traceHeader string) echo.HTTPErrorHandler {
+// returns a response as "text/plain; charset=UTF-8".
+func httpErrorHandler() echo.HTTPErrorHandler {
 	return func(err error, c echo.Context) {
-		parseError := func(err error) (int, string) {
-			echoErr, ok := err.(*echo.HTTPError)
-			if ok {
-				return echoErr.Code, http.StatusText(echoErr.Code)
-			}
-
-			if errors.Is(err, context.DeadlineExceeded) {
-				return http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable)
-			}
-
-			var httpErr HTTPError
-			if errors.As(err, &httpErr) {
-				return httpErr.HTTPError()
-			}
-
-			// Default 500 status code.
-			return http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)
-		}
-
-		status, message := parseError(err)
-
 		logger := c.Get("logger").(*zap.Logger)
-		clientOrNil := c.Get("webhookClient")
+		status, message := ParseError(err)
 
-		// No webhook client, meaning we can send the error as a response.
-		if clientOrNil == nil {
-			c.Response().Header().Add(echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8)
+		c.Response().Header().Add(echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8)
 
-			err = c.String(status, message)
-
-			if err != nil {
-				logger.Error(fmt.Sprintf("send error response: %s", err.Error()))
-			}
-
-			return
-		}
-
-		// We have to send the error to the webhook.
-		client := clientOrNil.(*webhookClient)
-
-		body := struct {
-			Status  int    `json:"status"`
-			Message string `json:"message"`
-		}{
-			Status:  status,
-			Message: message,
-		}
-
-		b, err := json.Marshal(body)
+		err = c.String(status, message)
 		if err != nil {
-			logger.Error(fmt.Sprintf("marshal JSON: %s", err.Error()))
-
-			return
-		}
-
-		headers := map[string]string{
-			echo.HeaderContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			traceHeader:            c.Get("trace").(string),
-		}
-
-		err = client.send(bytes.NewReader(b), headers, true)
-		if err != nil {
-			logger.Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
+			logger.Error(fmt.Sprintf("send error response: %s", err.Error()))
 		}
 	}
 }
@@ -116,7 +75,7 @@ func latencyMiddleware() echo.MiddlewareFunc {
 // URI.
 //
 //  rootPath := c.Get("rootPath").(string)
-//  healthURI := fmt.Sprintf("%shealth", rootPath)
+//  healthURI := fmt.Sprintf("%s/health", rootPath)
 //
 //  // Skip the middleware if health check URI.
 //  if c.Request().RequestURI == healthURI {
@@ -139,6 +98,7 @@ func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
 // the header is not present / its value is empty.
 //
 //  trace := c.Get("trace").(string)
+//  traceHeader := c.Get("traceHeader").(string).
 func traceMiddleware(header string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
@@ -150,6 +110,7 @@ func traceMiddleware(header string) echo.MiddlewareFunc {
 			}
 
 			c.Set("trace", trace)
+			c.Set("traceHeader", header)
 			c.Response().Header().Add(header, trace)
 
 			// Call the next middleware in the chain.
@@ -158,12 +119,30 @@ func traceMiddleware(header string) echo.MiddlewareFunc {
 	}
 }
 
+// timeoutsMiddleware sets the read, process and write timeouts in the
+// echo.Context under "readTimeout", "processTimeout" and "writeTimeout".
+//
+//  readTimeout := c.Get("readTimeout").(time.Duration)
+//  processTimeout := c.Get("processTimeout").(time.Duration)
+//  writeTimeout := c.Get("writeTimeout").(time.Duration)
+func timeoutsMiddleware(readTimeout, processTimeout, writeTimeout time.Duration) echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			c.Set("readTimeout", readTimeout)
+			c.Set("processTimeout", processTimeout)
+			c.Set("writeTimeout", writeTimeout)
+
+			// Call the next middleware in the chain.
+			return next(c)
+		}
+	}
+}
+
 // loggerMiddleware sets the logger in the echo.Context under "logger" and logs
-// a request result (but does not log a webhook call result, which is the job
-// of the webhookClient).
+// a synchronous request result.
 //
 //  logger := c.Get("logger").(*zap.Logger)
-func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.MiddlewareFunc {
+func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			startTime := c.Get("startTime").(time.Time)
@@ -179,11 +158,11 @@ func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.Midd
 				c.Error(err)
 			}
 
-			if skipHealthRouteLogging {
+			for _, path := range disableLoggingForPaths {
 				rootPath := c.Get("rootPath").(string)
-				healthURI := fmt.Sprintf("%shealth", rootPath)
+				URI := fmt.Sprintf("%s%s", rootPath, path)
 
-				if c.Request().RequestURI == healthURI {
+				if c.Request().RequestURI == URI {
 					return nil
 				}
 			}
@@ -225,317 +204,65 @@ func loggerMiddleware(logger *zap.Logger, skipHealthRouteLogging bool) echo.Midd
 	}
 }
 
-type contextMiddlewareConfig struct {
-	traceHeader string
-	timeout     struct {
-		process time.Duration
-		write   time.Duration
-	}
-	webhook struct {
-		allowList      *regexp.Regexp
-		denyList       *regexp.Regexp
-		errorAllowList *regexp.Regexp
-		errorDenyList  *regexp.Regexp
-		maxRetry       int
-		retryMinWait   time.Duration
-		retryMaxWait   time.Duration
-		disable        bool
-	}
-}
-
-// contextMiddleware handles the result of a "multipart/form-data" request. If
-// a webhook URL is present in the headers, exit early and process the result
-// in a goroutine.
-func contextMiddleware(cfg contextMiddlewareConfig) echo.MiddlewareFunc {
+// contextMiddleware, a middleware for "multipart/form-data" requests, sets the
+// Context and related context.CancelFunc in the echo.Context under "context"
+// and "cancel". If the process is synchronous, it also handles the result of a
+// "multipart/form-data" request.
+//
+//  ctx := c.Get("context").(*api.Context)
+//  cancel := c.Get("cancel").(context.CancelFunc)
+func contextMiddleware(processTimeout time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
-			webhookURL := c.Request().Header.Get("Gotenberg-Webhook-Url")
-			logger := c.Get("logger").(*zap.Logger).With(zap.Bool("webhook", webhookURL != ""))
+			logger := c.Get("logger").(*zap.Logger)
 
 			// We create a context with a timeout so that underlying processes are
 			// able to stop early and handle correctly a timeout scenario.
-			ctx, cancel, err := newContext(c, logger, cfg.timeout.process)
+			ctx, cancel, err := newContext(c, logger, processTimeout)
 			if err != nil {
 				cancel()
 
 				return fmt.Errorf("create request context: %w", err)
 			}
 			c.Set("context", ctx)
+			c.Set("cancel", cancel)
 
-			// Helper function for retrieving/creating the output filename.
-			outputFilename := func(outputPath string) string {
-				filename := c.Request().Header.Get("Gotenberg-Output-Filename")
+			// Call the next middleware in the chain.
+			err = next(c)
 
-				if filename == "" {
-					return filepath.Base(outputPath)
-				}
-
-				return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
+			if errors.Is(err, ErrAsyncProcess) {
+				// A middleware/handler tells us that it's handling the process
+				// in an asynchronous fashion. Therefore, we must not cancel
+				// the context nor send an output file.
+				return c.NoContent(http.StatusNoContent)
 			}
 
-			if webhookURL == "" {
-				defer cancel()
+			defer cancel()
 
-				// No webhook URL, call the next middleware in the chain.
-				err := next(c)
-
-				if err != nil {
-					return err
-				}
-
-				// No error, let's build the output file.
-				outputPath, err := ctx.buildOutputFile()
-				if err != nil {
-					return fmt.Errorf("build output file: %w", err)
-				}
-
-				// Send the output file.
-				err = c.Attachment(outputPath, outputFilename(outputPath))
-				if err != nil {
-					return fmt.Errorf("send response: %w", err)
-				}
-
-				return nil
-			}
-
-			// Ok, we got a webhook URL.
-
-			if cfg.webhook.disable {
-				// The client requested the webhook feature, but it has been
-				// disabled. Let's tell the client about that.
-				cancel()
-
-				return WrapError(
-					errors.New("webhook feature requested but it is disabled"),
-					NewSentinelHTTPError(http.StatusForbidden, "Invalid 'Gotenberg-Webhook-Url' header: feature is disabled"),
-				)
-			}
-
-			// Do we have a webhook error URL in case of... error?
-			webhookErrorURL := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
-
-			if webhookErrorURL == "" {
-				cancel()
-
-				return WrapError(
-					errors.New("empty webhook error URL"),
-					NewSentinelHTTPError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
-				)
-			}
-
-			// Let's check if the webhook URLs are acceptable according to our
-			// allowed/denied lists.
-			filter := func(URL, header string, allowList, denyList *regexp.Regexp) error {
-				if !allowList.MatchString(URL) {
-					return WrapError(
-						fmt.Errorf("'%s' does not match the expression from the allowed list", URL),
-						NewSentinelHTTPError(
-							http.StatusForbidden,
-							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
-						),
-					)
-				}
-
-				if denyList.String() != "" && denyList.MatchString(URL) {
-					return WrapError(
-						fmt.Errorf("'%s' matches the expression from the denied list", URL),
-						NewSentinelHTTPError(
-							http.StatusForbidden,
-							fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
-						),
-					)
-				}
-
-				return nil
-			}
-
-			err = filter(webhookURL, "Gotenberg-Webhook-Url", cfg.webhook.allowList, cfg.webhook.denyList)
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("filter webhook URL: %w", err)
+				return err
 			}
 
-			err = filter(webhookErrorURL, "Gotenberg-Webhook-Error-Url", cfg.webhook.errorAllowList, cfg.webhook.errorDenyList)
+			// No error, let's build the output file.
+			outputPath, err := ctx.BuildOutputFile()
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("filter webhook error URL: %w", err)
+				return fmt.Errorf("build output file: %w", err)
 			}
 
-			// Let's check the HTTP methods for calling the webhook URLs.
-			methodFromHeader := func(header string) (string, error) {
-				method := c.Request().Header.Get(header)
-
-				if method == "" {
-					return http.MethodPost, nil
-				}
-
-				method = strings.ToUpper(method)
-
-				switch method {
-				case http.MethodPost:
-					return method, nil
-				case http.MethodPatch:
-					return method, nil
-				case http.MethodPut:
-					return method, nil
-				}
-
-				return "", WrapError(
-					fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
-					NewSentinelHTTPError(
-						http.StatusBadRequest,
-						fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method),
-					),
-				)
-			}
-
-			webhookMethod, err := methodFromHeader("Gotenberg-Webhook-Method")
+			// Send the output file.
+			err = c.Attachment(outputPath, ctx.OutputFilename(outputPath))
 			if err != nil {
-				cancel()
-
-				return fmt.Errorf("get method to use for webhook: %w", err)
+				return fmt.Errorf("send response: %w", err)
 			}
 
-			webhookErrorMethod, err := methodFromHeader("Gotenberg-Webhook-Error-Method")
-			if err != nil {
-				cancel()
-
-				return fmt.Errorf("get method to use for webhook error: %w", err)
-			}
-
-			// What about extra HTTP headers?
-			var extraHTTPHeaders map[string]string
-
-			extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
-			if extraHTTPHeadersJSON != "" {
-				err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
-				if err != nil {
-					cancel()
-
-					return WrapError(
-						fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
-						NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
-					)
-				}
-			}
-
-			client := &webhookClient{
-				url:              webhookURL,
-				method:           webhookMethod,
-				errorURL:         webhookErrorURL,
-				errorMethod:      webhookErrorMethod,
-				extraHTTPHeaders: extraHTTPHeaders,
-				startTime:        c.Get("startTime").(time.Time),
-
-				client: &retryablehttp.Client{
-					HTTPClient: &http.Client{
-						Timeout: cfg.timeout.write,
-					},
-					RetryMax:     cfg.webhook.maxRetry,
-					RetryWaitMin: cfg.webhook.retryMinWait,
-					RetryWaitMax: cfg.webhook.retryMaxWait,
-					Logger: leveledLogger{
-						logger: logger,
-					},
-					CheckRetry: retryablehttp.DefaultRetryPolicy,
-					Backoff:    retryablehttp.DefaultBackoff,
-				},
-				logger: logger,
-			}
-
-			c.Set("webhookClient", client)
-
-			// As a webhook URL has been given, we handle the request in a
-			// goroutine and return immediately.
-			go func() {
-				defer cancel()
-
-				// Call the next middleware in the chain.
-				err := next(c)
-
-				if err != nil {
-					// The process failed for whatever reason. Let's send the
-					// details to the webhook.
-					ctx.Log().Error(err.Error())
-					c.Error(err)
-
-					return
-				}
-
-				// No error, let's get build the output file.
-				outputPath, err := ctx.buildOutputFile()
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				outputFile, err := os.Open(outputPath)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("open output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				defer func() {
-					err := outputFile.Close()
-					if err != nil {
-						ctx.Log().Error(fmt.Sprintf("close output file: %s", err))
-					}
-				}()
-
-				fileHeader := make([]byte, 512)
-				_, err = outputFile.Read(fileHeader)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("read header of output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				fileStat, err := outputFile.Stat()
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("get stat from output file: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				_, err = outputFile.Seek(0, 0)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("reset output file reader: %s", err))
-					c.Error(err)
-
-					return
-				}
-
-				headers := map[string]string{
-					echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", outputFilename(outputPath)),
-					echo.HeaderContentType:        http.DetectContentType(fileHeader),
-					echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
-					cfg.traceHeader:               c.Get("trace").(string),
-				}
-
-				// Send the output file to the webhook.
-				err = client.send(bufio.NewReader(outputFile), headers, false)
-				if err != nil {
-					ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
-					c.Error(err)
-				}
-			}()
-
-			return c.NoContent(http.StatusNoContent)
+			return nil
 		}
 	}
 }
 
-// timeoutMiddleware manages hard timeout scenarios, i.e., when a route handler
-// fails to timeout as expected.
-func timeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
+// hardTimeoutMiddleware manages hard timeout scenarios, i.e., when a route
+// handler fails to timeout as expected.
+func hardTimeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			logger := c.Get("logger").(*zap.Logger)

pkg/modules/api/middlewares_test.go

@@ -3,28 +3,21 @@ package api
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
-	"regexp"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 )
 
-func TestHttpErrorHandler(t *testing.T) {
+func TestParseError(t *testing.T) {
 	for i, tc := range []struct {
 		err           error
-		webhookClient *webhookClient
 		expectStatus  int
 		expectMessage string
 	}{
@@ -46,30 +39,42 @@ func TestHttpErrorHandler(t *testing.T) {
 			expectStatus:  http.StatusBadRequest,
 			expectMessage: "foo",
 		},
+	} {
+		actualStatus, actualMessage := ParseError(tc.err)
+
+		if actualStatus != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, actualStatus)
+		}
+
+		if actualMessage != tc.expectMessage {
+			t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, actualMessage)
+		}
+	}
+}
+
+func TestHttpErrorHandler(t *testing.T) {
+	for i, tc := range []struct {
+		err           error
+		expectStatus  int
+		expectMessage string
+	}{
 		{
-			err: echo.ErrInternalServerError,
-			webhookClient: &webhookClient{
-				errorURL:    "http://localhost:%d/",
-				errorMethod: http.MethodPost,
-				client:      retryablehttp.NewClient(),
-				logger:      zap.NewNop(),
-			},
+			err:           echo.ErrInternalServerError,
 			expectStatus:  http.StatusInternalServerError,
 			expectMessage: http.StatusText(http.StatusInternalServerError),
 		},
 		{
-			err: echo.ErrInternalServerError,
-			webhookClient: &webhookClient{
-				errorURL:    "non-existent",
-				errorMethod: http.MethodPost,
-				client: func() *retryablehttp.Client {
-					client := retryablehttp.NewClient()
-					client.RetryMax = 0
-
-					return client
-				}(),
-				logger: zap.NewNop(),
-			},
+			err:           context.DeadlineExceeded,
+			expectStatus:  http.StatusServiceUnavailable,
+			expectMessage: http.StatusText(http.StatusServiceUnavailable),
+		},
+		{
+			err: WrapError(
+				errors.New("foo"),
+				NewSentinelHTTPError(http.StatusBadRequest, "foo"),
+			),
+			expectStatus:  http.StatusBadRequest,
+			expectMessage: "foo",
 		},
 	} {
 		recorder := httptest.NewRecorder()
@@ -81,105 +86,24 @@ func TestHttpErrorHandler(t *testing.T) {
 
 		c := srv.NewContext(request, recorder)
 		c.Set("logger", zap.NewNop())
-		c.Set("trace", "foo")
 
-		if tc.webhookClient != nil {
-			c.Set("webhookClient", tc.webhookClient)
+		handler := httpErrorHandler()
+		handler(tc.err, c)
+
+		contentType := recorder.Header().Get(echo.HeaderContentType)
+		if contentType != echo.MIMETextPlainCharsetUTF8 {
+			t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8, contentType)
 		}
 
-		if tc.webhookClient == nil {
-			handler := httpErrorHandler("Gotenberg-Trace")
-			handler(tc.err, c)
+		// Note: we cannot test the trace header in the response here, as it is set in the trace middleware.
 
-			contentType := recorder.Header().Get(echo.HeaderContentType)
-			if contentType != echo.MIMETextPlainCharsetUTF8 {
-				t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMETextPlainCharsetUTF8, contentType)
-			}
-
-			// Note: we cannot test the trace header in the response here, as it is set in the trace middleware.
-
-			if recorder.Code != tc.expectStatus {
-				t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
-			}
-
-			if recorder.Body.String() != tc.expectMessage {
-				t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, recorder.Body.String())
-			}
-
-			continue
+		if recorder.Code != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
 		}
 
-		func() {
-			rand.Seed(time.Now().UnixNano())
-			webhookPort := rand.Intn(65535-1025+1) + 1025
-
-			tc.webhookClient.errorURL = fmt.Sprintf(tc.webhookClient.errorURL, webhookPort)
-
-			c.Set("webhookClient", tc.webhookClient)
-
-			webhook := echo.New()
-			webhook.HideBanner = true
-			webhook.HidePort = true
-
-			webhook.POST(
-				"/",
-				func() echo.HandlerFunc {
-					return func(c echo.Context) error {
-						contentType := c.Request().Header.Get(echo.HeaderContentType)
-						if contentType != echo.MIMEApplicationJSONCharsetUTF8 {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, echo.MIMEApplicationJSONCharsetUTF8, contentType)
-						}
-
-						trace := c.Request().Header.Get("Gotenberg-Trace")
-						if trace != "foo" {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, "Gotenberg-Trace", "foo", trace)
-						}
-
-						body, err := ioutil.ReadAll(c.Request().Body)
-						if err != nil {
-							t.Fatalf("test %d: expected not error but got: %v", i, err)
-						}
-
-						result := struct {
-							Status  int    `json:"status"`
-							Message string `json:"message"`
-						}{}
-
-						err = json.Unmarshal(body, &result)
-						if err != nil {
-							t.Fatalf("test %d: expected not error but got: %v", i, err)
-						}
-
-						if result.Status != tc.expectStatus {
-							t.Errorf("test %d: expected status %d from JSON but got %d", i, tc.expectStatus, result.Status)
-						}
-
-						if result.Message != tc.expectMessage {
-							t.Errorf("test %d: expected message '%s' from JSON but got '%s'", i, tc.expectMessage, result.Message)
-						}
-
-						return nil
-					}
-				}(),
-			)
-
-			go func(server *echo.Echo, port, i int) {
-				err := webhook.Start(fmt.Sprintf(":%d", port))
-				if !errors.Is(err, http.ErrServerClosed) {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}(webhook, webhookPort, i)
-
-			defer func() {
-				err := webhook.Shutdown(context.TODO())
-				if err != nil {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			handler := httpErrorHandler("Gotenberg-Trace")
-			handler(tc.err, c)
-		}()
+		if recorder.Body.String() != tc.expectMessage {
+			t.Errorf("test %d: expected message '%s' but got '%s'", i, tc.expectMessage, recorder.Body.String())
+		}
 	}
 }
 
@@ -298,11 +222,52 @@ func TestTraceMiddleware(t *testing.T) {
 	}
 }
 
+func TestTimeoutsMiddleware(t *testing.T) {
+	recorder := httptest.NewRecorder()
+	request := httptest.NewRequest(http.MethodGet, "/foo", nil)
+
+	srv := echo.New()
+	srv.HideBanner = true
+	srv.HidePort = true
+
+	c := srv.NewContext(request, recorder)
+
+	expectReadTimeout := time.Duration(1) * time.Second
+	expectProcessTimeout := time.Duration(2) * time.Second
+	expectWriteTimeout := time.Duration(3) * time.Second
+
+	err := timeoutsMiddleware(expectReadTimeout, expectProcessTimeout, expectWriteTimeout)(
+		func(c echo.Context) error {
+			return nil
+		},
+	)(c)
+
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+
+	actualReadTimeout := c.Get("readTimeout").(time.Duration)
+	actualProcessTimeout := c.Get("processTimeout").(time.Duration)
+	actualWriteTimeout := c.Get("writeTimeout").(time.Duration)
+
+	if actualReadTimeout != expectReadTimeout {
+		t.Errorf("expected '%s' but got '%s", expectReadTimeout, actualReadTimeout)
+	}
+
+	if actualProcessTimeout != expectProcessTimeout {
+		t.Errorf("expected '%s' but got '%s", expectProcessTimeout, actualProcessTimeout)
+	}
+
+	if actualWriteTimeout != expectWriteTimeout {
+		t.Errorf("expected '%s' but got '%s", actualWriteTimeout, expectWriteTimeout)
+	}
+}
+
 func TestLoggerMiddleware(t *testing.T) {
 	for i, tc := range []struct {
-		request                *http.Request
-		next                   echo.HandlerFunc
-		skipHealthRouteLogging bool
+		request     *http.Request
+		next        echo.HandlerFunc
+		skipLogging bool
 	}{
 		{
 			request: httptest.NewRequest(http.MethodGet, "/", nil),
@@ -319,7 +284,7 @@ func TestLoggerMiddleware(t *testing.T) {
 					return nil
 				}
 			}(),
-			skipHealthRouteLogging: true,
+			skipLogging: true,
 		},
 		{
 			request: httptest.NewRequest(http.MethodGet, "/health", nil),
@@ -341,7 +306,12 @@ func TestLoggerMiddleware(t *testing.T) {
 		c.Set("trace", "foo")
 		c.Set("rootPath", "/")
 
-		err := loggerMiddleware(zap.NewNop(), tc.skipHealthRouteLogging)(tc.next)(c)
+		var disableLoggingForPaths []string
+		if tc.skipLogging {
+			disableLoggingForPaths = append(disableLoggingForPaths, tc.request.RequestURI)
+		}
+
+		err := loggerMiddleware(zap.NewNop(), disableLoggingForPaths)(tc.next)(c)
 
 		if err != nil {
 			t.Errorf("test %d: expected no error but got: %v", i, err)
@@ -349,7 +319,7 @@ func TestLoggerMiddleware(t *testing.T) {
 	}
 }
 
-func TestContextMiddlewareWithoutWebhook(t *testing.T) {
+func TestContextMiddleware(t *testing.T) {
 	buildMultipartFormDataRequest := func() *http.Request {
 		body := &bytes.Buffer{}
 		writer := multipart.NewWriter(body)
@@ -376,6 +346,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 		request           *http.Request
 		next              echo.HandlerFunc
 		expectErr         bool
+		expectStatus      int
 		expectContentType string
 		expectFilename    string
 	}{
@@ -383,6 +354,15 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 			request:   httptest.NewRequest(http.MethodGet, "/", nil),
 			expectErr: true,
 		},
+		{
+			request: buildMultipartFormDataRequest(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return ErrAsyncProcess
+				}
+			}(),
+			expectStatus: http.StatusNoContent,
+		},
 		{
 			request: buildMultipartFormDataRequest(),
 			next: func() echo.HandlerFunc {
@@ -418,6 +398,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 					return nil
 				}
 			}(),
+			expectStatus:      http.StatusOK,
 			expectContentType: "application/pdf",
 			expectFilename:    "foo.pdf",
 		},
@@ -434,6 +415,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 					return nil
 				}
 			}(),
+			expectStatus:      http.StatusOK,
 			expectContentType: "application/zip",
 		},
 	} {
@@ -448,16 +430,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 		c.Set("trace", "foo")
 		c.Set("startTime", time.Now())
 
-		cfg := contextMiddlewareConfig{
-			timeout: struct {
-				process time.Duration
-				write   time.Duration
-			}{
-				process: time.Duration(10) * time.Second,
-			},
-		}
-
-		err := contextMiddleware(cfg)(tc.next)(c)
+		err := contextMiddleware(time.Duration(10) * time.Second)(tc.next)(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -471,8 +444,12 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 			continue
 		}
 
-		if recorder.Code != http.StatusOK {
-			t.Errorf("test %d: expected HTTP status code %d but got %d", i, http.StatusOK, recorder.Code)
+		if recorder.Code != tc.expectStatus {
+			t.Errorf("test %d: expected HTTP status code %d but got %d", i, tc.expectStatus, recorder.Code)
+		}
+
+		if tc.expectStatus == http.StatusNoContent {
+			continue
 		}
 
 		contentType := recorder.Header().Get(echo.HeaderContentType)
@@ -487,470 +464,7 @@ func TestContextMiddlewareWithoutWebhook(t *testing.T) {
 	}
 }
 
-func TestContextMiddlewareWithWebhook(t *testing.T) {
-	buildMultipartFormDataRequest := func() *http.Request {
-		body := &bytes.Buffer{}
-		writer := multipart.NewWriter(body)
-
-		defer func() {
-			err := writer.Close()
-			if err != nil {
-				t.Fatalf("expected no error but got: %v", err)
-			}
-		}()
-
-		err := writer.WriteField("foo", "foo")
-		if err != nil {
-			t.Fatalf("expected no error but got: %v", err)
-		}
-
-		req := httptest.NewRequest(http.MethodPost, "/", body)
-		req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
-
-		return req
-	}
-
-	buildContextMiddlewareConfig := func() contextMiddlewareConfig {
-		return contextMiddlewareConfig{
-			traceHeader: "Gotenberg-Trace",
-			timeout: struct {
-				process time.Duration
-				write   time.Duration
-			}{
-				process: time.Duration(10) * time.Second,
-				write:   time.Duration(10) * time.Second,
-			},
-			webhook: struct {
-				allowList      *regexp.Regexp
-				denyList       *regexp.Regexp
-				errorAllowList *regexp.Regexp
-				errorDenyList  *regexp.Regexp
-				maxRetry       int
-				retryMinWait   time.Duration
-				retryMaxWait   time.Duration
-				disable        bool
-			}{
-				allowList:      regexp.MustCompile(""),
-				denyList:       regexp.MustCompile(""),
-				errorAllowList: regexp.MustCompile(""),
-				errorDenyList:  regexp.MustCompile(""),
-			},
-		}
-	}
-
-	for i, tc := range []struct {
-		request                       *http.Request
-		cfg                           contextMiddlewareConfig
-		next                          echo.HandlerFunc
-		autoWebhookURLs               bool
-		expectErr                     bool
-		expectHTTPErr                 bool
-		expectHTTPStatus              int
-		expectWebhookContentType      string
-		expectWebhookMethod           string
-		expectWebhookExtraHTTPHeaders map[string]string
-		expectWebhookFilename         string
-	}{
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.disable = true
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.allowList = regexp.MustCompile("bar")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.denyList = regexp.MustCompile("foo")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.errorAllowList = regexp.MustCompile("foo")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg: func() contextMiddlewareConfig {
-				cfg := buildContextMiddlewareConfig()
-				cfg.webhook.errorDenyList = regexp.MustCompile("bar")
-
-				return cfg
-			}(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusForbidden,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodGet)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPost)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPatch)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPut)
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Webhook-Url", "foo")
-				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
-				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", "foo")
-
-				return req
-			}(),
-			cfg:              buildContextMiddlewareConfig(),
-			expectErr:        true,
-			expectHTTPErr:    true,
-			expectHTTPStatus: http.StatusBadRequest,
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					return errors.New("foo")
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			expectWebhookMethod:      http.MethodPost,
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					return nil
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: echo.MIMEApplicationJSONCharsetUTF8,
-			expectWebhookMethod:      http.MethodPost,
-		},
-		{
-			request: func() *http.Request {
-				req := buildMultipartFormDataRequest()
-				req.Header.Set("Gotenberg-Output-Filename", "foo")
-				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", `{ "foo": "bar" }`)
-
-				return req
-			}(),
-			cfg: buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-					ctx.outputPaths = []string{
-						"/tests/test/testdata/api/sample2.pdf",
-					}
-
-					return nil
-				}
-			}(),
-			autoWebhookURLs:               true,
-			expectWebhookContentType:      "application/pdf",
-			expectWebhookMethod:           http.MethodPost,
-			expectWebhookFilename:         "foo",
-			expectWebhookExtraHTTPHeaders: map[string]string{"foo": "bar"},
-		},
-		{
-			request: buildMultipartFormDataRequest(),
-			cfg:     buildContextMiddlewareConfig(),
-			next: func() echo.HandlerFunc {
-				return func(c echo.Context) error {
-					ctx := c.Get("context").(*Context)
-					ctx.outputPaths = []string{
-						"/tests/test/testdata/api/sample1.txt",
-						"/tests/test/testdata/api/sample2.pdf",
-					}
-
-					return nil
-				}
-			}(),
-			autoWebhookURLs:          true,
-			expectWebhookContentType: "application/zip",
-			expectWebhookMethod:      http.MethodPost,
-		},
-	} {
-		func() {
-			recorder := httptest.NewRecorder()
-
-			srv := echo.New()
-			srv.HideBanner = true
-			srv.HidePort = true
-			srv.HTTPErrorHandler = httpErrorHandler(tc.cfg.traceHeader)
-
-			c := srv.NewContext(tc.request, recorder)
-			c.Set("logger", zap.NewNop())
-			c.Set("trace", "foo")
-			c.Set("startTime", time.Now())
-
-			webhook := echo.New()
-			webhook.HideBanner = true
-			webhook.HidePort = true
-
-			rand.Seed(time.Now().UnixNano())
-			webhookPort := rand.Intn(65535-1025+1) + 1025
-
-			if tc.autoWebhookURLs {
-				c.Request().Header.Set("Gotenberg-Webhook-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
-				c.Request().Header.Set("Gotenberg-Webhook-Error-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
-			}
-
-			errChan := make(chan error, 1)
-
-			webhook.POST(
-				"/",
-				func() echo.HandlerFunc {
-					return func(c echo.Context) error {
-						contentType := c.Request().Header.Get(echo.HeaderContentType)
-						if contentType != tc.expectWebhookContentType {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, echo.HeaderContentType, tc.expectWebhookContentType, contentType)
-						}
-
-						trace := c.Request().Header.Get(tc.cfg.traceHeader)
-						if trace != "foo" {
-							t.Errorf("test %d: expected %s '%s' but got '%s'", i, "Gotenberg-Trace", "foo", trace)
-						}
-
-						method := c.Request().Method
-						if method != tc.expectWebhookMethod {
-							t.Errorf("test %d: expected HTTP method '%s' but got '%s'", i, tc.expectWebhookMethod, method)
-						}
-
-						for key, expect := range tc.expectWebhookExtraHTTPHeaders {
-							actual := c.Request().Header.Get(key)
-
-							if actual != expect {
-								t.Errorf("test %d: expected %s '%s' but got '%s'", i, key, expect, actual)
-							}
-						}
-
-						if tc.expectWebhookContentType == echo.MIMEApplicationJSONCharsetUTF8 {
-							errChan <- nil
-							return nil
-						}
-
-						contentLength := c.Request().Header.Get(echo.HeaderContentLength)
-						if contentLength == "" {
-							t.Errorf("test %d: expected non empty %s", i, echo.HeaderContentLength)
-						}
-
-						contentDisposition := c.Request().Header.Get(echo.HeaderContentDisposition)
-						if !strings.Contains(contentDisposition, tc.expectWebhookFilename) {
-							t.Errorf("test %d: expected %s '%s' to contain '%s'", i, echo.HeaderContentDisposition, contentDisposition, tc.expectWebhookFilename)
-						}
-
-						body, err := ioutil.ReadAll(c.Request().Body)
-						if err != nil {
-							errChan <- err
-							return nil
-						}
-
-						if body == nil || len(body) == 0 {
-							t.Errorf("test %d: expected non nil body", i)
-						}
-
-						errChan <- nil
-						return nil
-					}
-				}(),
-			)
-
-			go func(server *echo.Echo, port, i int) {
-				err := server.Start(fmt.Sprintf(":%d", webhookPort))
-				if !errors.Is(err, http.ErrServerClosed) {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}(webhook, webhookPort, i)
-
-			defer func() {
-				err := webhook.Shutdown(context.TODO())
-				if err != nil {
-					t.Errorf("test %d: expected no error but got: %v", i, err)
-				}
-			}()
-
-			err := contextMiddleware(tc.cfg)(tc.next)(c)
-
-			if tc.expectErr && err == nil {
-				t.Errorf("test %d: expected error but got: %v", i, err)
-			}
-
-			if !tc.expectErr && err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-
-			var httpErr HTTPError
-			isHTTPErr := errors.As(err, &httpErr)
-
-			if tc.expectHTTPErr && !isHTTPErr {
-				t.Errorf("test %d: expected HTTP error but got: %v", i, err)
-			}
-
-			if !tc.expectHTTPErr && isHTTPErr {
-				t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
-			}
-
-			if err != nil && tc.expectHTTPErr && isHTTPErr {
-				status, _ := httpErr.HTTPError()
-				if status != tc.expectHTTPStatus {
-					t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
-				}
-			}
-
-			if err != nil {
-				return
-			}
-
-			if recorder.Code != http.StatusNoContent {
-				t.Errorf("test %d: expected HTTP status code %d but got %d", i, http.StatusNoContent, recorder.Code)
-			}
-
-			err = <-errChan
-			if err != nil {
-				t.Errorf("test %d: expected no error but got: %v", i, err)
-			}
-		}()
-	}
-}
-
-func TestTimeoutMiddleware(t *testing.T) {
+func TestHardTimeoutMiddleware(t *testing.T) {
 	for i, tc := range []struct {
 		next              echo.HandlerFunc
 		timeout           time.Duration
@@ -1007,7 +521,7 @@ func TestTimeoutMiddleware(t *testing.T) {
 		c := srv.NewContext(request, recorder)
 		c.Set("logger", zap.NewNop())
 
-		err := timeoutMiddleware(tc.timeout)(tc.next)(c)
+		err := hardTimeoutMiddleware(tc.timeout)(tc.next)(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)

pkg/modules/chromium/chromium.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/chromedp/cdproto/fetch"
@@ -236,19 +237,35 @@ func (mod Chromium) Validate() error {
 	return nil
 }
 
+// Metrics returns the metrics.
+func (mod Chromium) Metrics() ([]gotenberg.Metric, error) {
+	return []gotenberg.Metric{
+		{
+			Name:        "chromium_active_instances_count",
+			Description: "Current number of active Chromium instances.",
+			Read: func() float64 {
+				activeInstancesCountMu.RLock()
+				defer activeInstancesCountMu.RUnlock()
+
+				return activeInstancesCount
+			},
+		},
+	}, nil
+}
+
 // Chromium returns an API for interacting with Chromium for converting HTML
 // documents to PDF.
 func (mod Chromium) Chromium() (API, error) {
 	return mod, nil
 }
 
-// Routes returns the API routes.
-func (mod Chromium) Routes() ([]api.MultipartFormDataRoute, error) {
+// Routes returns the HTTP routes.
+func (mod Chromium) Routes() ([]api.Route, error) {
 	if mod.disableRoutes {
 		return nil, nil
 	}
 
-	return []api.MultipartFormDataRoute{
+	return []api.Route{
 		convertURLRoute(mod, mod.engine),
 		convertHTMLRoute(mod, mod.engine),
 		convertMarkdownRoute(mod, mod.engine),
@@ -475,9 +492,17 @@ func (mod Chromium) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath
 		}
 	}
 
+	activeInstancesCountMu.Lock()
+	activeInstancesCount += 1
+	activeInstancesCountMu.Unlock()
+
 	var buffer []byte
 	err := chromedp.Run(taskCtx, printToPDF(URL, options, &buffer))
 
+	activeInstancesCountMu.Lock()
+	activeInstancesCount -= 1
+	activeInstancesCountMu.Unlock()
+
 	// Always remove the user profile directory created by Chromium.
 	go func() {
 		logger.Debug(fmt.Sprintf("remove user profile directory '%s'", userProfileDirPath))
@@ -514,12 +539,18 @@ func (mod Chromium) PDF(ctx context.Context, logger *zap.Logger, URL, outputPath
 	return nil
 }
 
+var (
+	activeInstancesCount   float64
+	activeInstancesCountMu sync.RWMutex
+)
+
 // Interface guards.
 var (
-	_ gotenberg.Module            = (*Chromium)(nil)
-	_ gotenberg.Provisioner       = (*Chromium)(nil)
-	_ gotenberg.Validator         = (*Chromium)(nil)
-	_ api.MultipartFormDataRouter = (*Chromium)(nil)
-	_ API                         = (*Chromium)(nil)
-	_ Provider                    = (*Chromium)(nil)
+	_ gotenberg.Module          = (*Chromium)(nil)
+	_ gotenberg.Provisioner     = (*Chromium)(nil)
+	_ gotenberg.Validator       = (*Chromium)(nil)
+	_ gotenberg.MetricsProvider = (*Chromium)(nil)
+	_ api.Router                = (*Chromium)(nil)
+	_ API                       = (*Chromium)(nil)
+	_ Provider                  = (*Chromium)(nil)
 )

pkg/modules/chromium/chromium_test.go

@@ -173,6 +173,22 @@ func TestChromium_Validate(t *testing.T) {
 	}
 }
 
+func TestChromium_Metrics(t *testing.T) {
+	metrics, err := new(Chromium).Metrics()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	if len(metrics) != 1 {
+		t.Errorf("expected %d metrics, but got %d", 1, len(metrics))
+	}
+
+	actual := metrics[0].Read()
+	if actual != 0 {
+		t.Errorf("expected %d Chromium instances, but got %f", 0, actual)
+	}
+}
+
 func TestChromium_Chromium(t *testing.T) {
 	mod := new(Chromium)
 

pkg/modules/chromium/routes.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 	"github.com/microcosm-cc/bluemonday"
 	"github.com/russross/blackfriday/v2"
 	"go.uber.org/multierr"
@@ -89,12 +90,14 @@ func FormDataChromiumPDFOptions(ctx *api.Context) (*api.FormData, Options) {
 	return form, options
 }
 
-// convertURLRoute returns an api.MultipartFormDataRoute route which can
-// convert a URL to PDF.
-func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/url",
-		Handler: func(ctx *api.Context) error {
+// convertURLRoute returns an api.Route which can convert a URL to PDF.
+func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/url",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPDFOptions(ctx)
 
 			var (
@@ -121,12 +124,14 @@ func convertURLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartForm
 	}
 }
 
-// convertHTMLRoute returns an api.MultipartFormDataRoute route which can
-// convert an HTML file to PDF.
-func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/html",
-		Handler: func(ctx *api.Context) error {
+// convertHTMLRoute returns an api.Route which can convert an HTML file to PDF.
+func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/html",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPDFOptions(ctx)
 
 			var (
@@ -155,12 +160,15 @@ func convertHTMLRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFor
 	}
 }
 
-// convertMarkdownRoute returns an api.MultipartFormDataRoute route which can
-// convert markdown files to PDF.
-func convertMarkdownRoute(chromium API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/chromium/convert/markdown",
-		Handler: func(ctx *api.Context) error {
+// convertMarkdownRoute returns an api.Route which can convert markdown files
+// to PDF.
+func convertMarkdownRoute(chromium API, engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/chromium/convert/markdown",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPDFOptions(ctx)
 
 			var (

pkg/modules/chromium/routes_test.go

@@ -3,13 +3,14 @@ package chromium
 import (
 	"context"
 	"errors"
-	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"net/http"
 	"os"
 	"reflect"
 	"testing"
 
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 )
 
@@ -137,7 +138,10 @@ func TestConvertURLHandler(t *testing.T) {
 			expectOutputPathsCount: 1,
 		},
 	} {
-		err := convertURLRoute(tc.api, nil).Handler(tc.ctx.Context)
+		c := echo.New().NewContext(nil, nil)
+		c.Set("context", tc.ctx.Context)
+
+		err := convertURLRoute(tc.api, nil).Handler(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -238,7 +242,10 @@ func TestConvertHTMLHandler(t *testing.T) {
 			expectOutputPathsCount: 1,
 		},
 	} {
-		err := convertHTMLRoute(tc.api, nil).Handler(tc.ctx.Context)
+		c := echo.New().NewContext(nil, nil)
+		c.Set("context", tc.ctx.Context)
+
+		err := convertHTMLRoute(tc.api, nil).Handler(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -472,7 +479,10 @@ func TestConvertMarkdownHandler(t *testing.T) {
 				}()
 			}
 
-			err := convertMarkdownRoute(tc.api, nil).Handler(tc.ctx.Context)
+			c := echo.New().NewContext(nil, nil)
+			c.Set("context", tc.ctx.Context)
+
+			err := convertMarkdownRoute(tc.api, nil).Handler(c)
 
 			if tc.expectErr && err == nil {
 				t.Errorf("test %d: expected error but got: %v", i, err)

pkg/modules/libreoffice/libreoffice.go

@@ -67,20 +67,20 @@ func (mod *LibreOffice) Provision(ctx *gotenberg.Context) error {
 	return nil
 }
 
-// Routes returns the API routes.
-func (mod LibreOffice) Routes() ([]api.MultipartFormDataRoute, error) {
+// Routes returns the HTTP routes.
+func (mod LibreOffice) Routes() ([]api.Route, error) {
 	if mod.disableRoutes {
 		return nil, nil
 	}
 
-	return []api.MultipartFormDataRoute{
+	return []api.Route{
 		convertRoute(mod.unoconv, mod.engine),
 	}, nil
 }
 
 // Interface guards.
 var (
-	_ gotenberg.Module            = (*LibreOffice)(nil)
-	_ gotenberg.Provisioner       = (*LibreOffice)(nil)
-	_ api.MultipartFormDataRouter = (*LibreOffice)(nil)
+	_ gotenberg.Module      = (*LibreOffice)(nil)
+	_ gotenberg.Provisioner = (*LibreOffice)(nil)
+	_ api.Router            = (*LibreOffice)(nil)
 )

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -20,7 +20,7 @@ type UnoconvPDFEngine struct {
 }
 
 // Descriptor returns a UnoconvPDFEngine's module descriptor.
-func (engine UnoconvPDFEngine) Descriptor() gotenberg.ModuleDescriptor {
+func (UnoconvPDFEngine) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID:  "unoconv-pdfengine",
 		New: func() gotenberg.Module { return new(UnoconvPDFEngine) },

pkg/modules/libreoffice/routes.go

@@ -8,14 +8,19 @@ import (
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"github.com/labstack/echo/v4"
 )
 
-// convertRoute returns an api.MultipartFormDataRoute which can convert
-// LibreOffice documents to PDF.
-func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/libreoffice/convert",
-		Handler: func(ctx *api.Context) error {
+// convertRoute returns an api.Route which can convert LibreOffice documents
+// to PDF.
+func convertRoute(uno unoconv.API, engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/libreoffice/convert",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
 				inputPaths         []string

pkg/modules/libreoffice/routes_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/libreoffice/unoconv"
+	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 )
 
@@ -506,7 +507,10 @@ func TestConvertHandler(t *testing.T) {
 			expectOutputPathsCount: 2,
 		},
 	} {
-		err := convertRoute(tc.api, tc.engine).Handler(tc.ctx.Context)
+		c := echo.New().NewContext(nil, nil)
+		c.Set("context", tc.ctx.Context)
+
+		err := convertRoute(tc.api, tc.engine).Handler(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)

pkg/modules/libreoffice/unoconv/unoconv.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
@@ -94,6 +95,22 @@ func (mod Unoconv) Validate() error {
 	return nil
 }
 
+// Metrics returns the metrics.
+func (mod Unoconv) Metrics() ([]gotenberg.Metric, error) {
+	return []gotenberg.Metric{
+		{
+			Name:        "unoconv_active_instances_count",
+			Description: "Current number of active LibreOffice instances.",
+			Read: func() float64 {
+				activeInstancesCountMu.RLock()
+				defer activeInstancesCountMu.RUnlock()
+
+				return activeInstancesCount
+			},
+		},
+	}, nil
+}
+
 // Unoconv returns an API for interacting with unoconv.
 func (mod Unoconv) Unoconv() (API, error) {
 	return mod, nil
@@ -163,8 +180,16 @@ func (mod Unoconv) PDF(ctx context.Context, logger *zap.Logger, inputPath, outpu
 
 	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
 
+	activeInstancesCountMu.Lock()
+	activeInstancesCount += 1
+	activeInstancesCountMu.Unlock()
+
 	err = cmd.Exec()
 
+	activeInstancesCountMu.Lock()
+	activeInstancesCount -= 1
+	activeInstancesCountMu.Unlock()
+
 	// Always remove the user profile directory created by LibreOffice.
 	// See https://github.com/gotenberg/gotenberg/issues/192.
 	go func() {
@@ -280,11 +305,17 @@ func (mod Unoconv) Extensions() []string {
 	}
 }
 
+var (
+	activeInstancesCount   float64
+	activeInstancesCountMu sync.RWMutex
+)
+
 // Interface guards.
 var (
-	_ gotenberg.Module      = (*Unoconv)(nil)
-	_ gotenberg.Provisioner = (*Unoconv)(nil)
-	_ gotenberg.Validator   = (*Unoconv)(nil)
-	_ API                   = (*Unoconv)(nil)
-	_ Provider              = (*Unoconv)(nil)
+	_ gotenberg.Module          = (*Unoconv)(nil)
+	_ gotenberg.Provisioner     = (*Unoconv)(nil)
+	_ gotenberg.Validator       = (*Unoconv)(nil)
+	_ gotenberg.MetricsProvider = (*Unoconv)(nil)
+	_ API                       = (*Unoconv)(nil)
+	_ Provider                  = (*Unoconv)(nil)
 )

pkg/modules/libreoffice/unoconv/unoconv_test.go

@@ -61,6 +61,22 @@ func TestUnoconv_Validate(t *testing.T) {
 	}
 }
 
+func TestChromium_Metrics(t *testing.T) {
+	metrics, err := new(Unoconv).Metrics()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	if len(metrics) != 1 {
+		t.Errorf("expected %d metrics, but got %d", 1, len(metrics))
+	}
+
+	actual := metrics[0].Read()
+	if actual != 0 {
+		t.Errorf("expected %d unoconv instances, but got %f", 0, actual)
+	}
+}
+
 func TestUnoconv_Unoconv(t *testing.T) {
 	mod := new(Unoconv)
 

pkg/modules/pdfcpu/pdfcpu.go

@@ -22,7 +22,7 @@ type PDFcpu struct {
 }
 
 // Descriptor returns a PDFcpu's module descriptor.
-func (engine PDFcpu) Descriptor() gotenberg.ModuleDescriptor {
+func (PDFcpu) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID:  "pdfcpu",
 		New: func() gotenberg.Module { return new(PDFcpu) },

pkg/modules/pdfengines/pdfengines.go

@@ -131,8 +131,8 @@ func (mod PDFEngines) PDFEngine() (gotenberg.PDFEngine, error) {
 	return newMultiPDFEngines(engines...), nil
 }
 
-// Routes returns the API routes.
-func (mod PDFEngines) Routes() ([]api.MultipartFormDataRoute, error) {
+// Routes returns the HTTP routes.
+func (mod PDFEngines) Routes() ([]api.Route, error) {
 	if mod.disableRoutes {
 		return nil, nil
 	}
@@ -144,7 +144,7 @@ func (mod PDFEngines) Routes() ([]api.MultipartFormDataRoute, error) {
 		return nil, fmt.Errorf("get pdf engine: %w", err)
 	}
 
-	return []api.MultipartFormDataRoute{
+	return []api.Route{
 		mergeRoute(engine),
 		convertRoute(engine),
 	}, nil
@@ -156,5 +156,5 @@ var (
 	_ gotenberg.Provisioner       = (*PDFEngines)(nil)
 	_ gotenberg.Validator         = (*PDFEngines)(nil)
 	_ gotenberg.PDFEngineProvider = (*PDFEngines)(nil)
-	_ api.MultipartFormDataRouter = (*PDFEngines)(nil)
+	_ api.Router                  = (*PDFEngines)(nil)
 )

pkg/modules/pdfengines/routes.go

@@ -7,13 +7,18 @@ import (
 
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 )
 
-// mergeRoute returns an api.MultipartFormDataRoute which can merge PDFs.
-func mergeRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/pdfengines/merge",
-		Handler: func(ctx *api.Context) error {
+// mergeRoute returns an api.Route which can merge PDFs.
+func mergeRoute(engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/merge",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
 				inputPaths []string
@@ -79,12 +84,16 @@ func mergeRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
 	}
 }
 
-// convertRoute returns an api.MultipartFormDataRoute which can convert a PDF
-// to a specific PDF format.
-func convertRoute(engine gotenberg.PDFEngine) api.MultipartFormDataRoute {
-	return api.MultipartFormDataRoute{
-		Path: "/pdfengines/convert",
-		Handler: func(ctx *api.Context) error {
+// convertRoute returns an api.Route which can convert a PDF to a specific PDF
+// format.
+func convertRoute(engine gotenberg.PDFEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/convert",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
 			// Let's get the data from the form and validate them.
 			var (
 				inputPaths []string

pkg/modules/pdfengines/routes_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
 )
 
@@ -168,7 +169,10 @@ func TestMergeHandler(t *testing.T) {
 			expectOutputPathsCount: 1,
 		},
 	} {
-		err := mergeRoute(tc.engine).Handler(tc.ctx.Context)
+		c := echo.New().NewContext(nil, nil)
+		c.Set("context", tc.ctx.Context)
+
+		err := mergeRoute(tc.engine).Handler(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
@@ -357,7 +361,10 @@ func TestConvertHandler(t *testing.T) {
 			expectOutputPathsCount: 2,
 		},
 	} {
-		err := convertRoute(tc.engine).Handler(tc.ctx.Context)
+		c := echo.New().NewContext(nil, nil)
+		c.Set("context", tc.ctx.Context)
+
+		err := convertRoute(tc.engine).Handler(c)
 
 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)

pkg/modules/pdftk/pdftk.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"sync"
 
 	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
 	"go.uber.org/zap"
@@ -21,7 +22,7 @@ type PDFtk struct {
 }
 
 // Descriptor returns a PDFtk's module descriptor.
-func (engine PDFtk) Descriptor() gotenberg.ModuleDescriptor {
+func (PDFtk) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
 		ID:  "pdftk",
 		New: func() gotenberg.Module { return new(PDFtk) },
@@ -51,6 +52,22 @@ func (engine PDFtk) Validate() error {
 	return nil
 }
 
+// Metrics returns the metrics.
+func (engine PDFtk) Metrics() ([]gotenberg.Metric, error) {
+	return []gotenberg.Metric{
+		{
+			Name:        "pdftk_active_instances_count",
+			Description: "Current number of active PDFtk instances.",
+			Read: func() float64 {
+				activeInstancesCountMu.RLock()
+				defer activeInstancesCountMu.RUnlock()
+
+				return activeInstancesCount
+			},
+		},
+	}, nil
+}
+
 // Merge merges the given PDFs into a unique PDF.
 func (engine PDFtk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var args []string
@@ -62,7 +79,16 @@ func (engine PDFtk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 		return fmt.Errorf("create command: %w", err)
 	}
 
+	activeInstancesCountMu.Lock()
+	activeInstancesCount += 1
+	activeInstancesCountMu.Unlock()
+
 	err = cmd.Exec()
+
+	activeInstancesCountMu.Lock()
+	activeInstancesCount -= 1
+	activeInstancesCountMu.Unlock()
+
 	if err == nil {
 		return nil
 	}
@@ -75,10 +101,16 @@ func (engine PDFtk) Convert(_ context.Context, _ *zap.Logger, format, _, _ strin
 	return fmt.Errorf("convert PDF to '%s' with PDFtk: %w", format, gotenberg.ErrPDFEngineMethodNotAvailable)
 }
 
+var (
+	activeInstancesCount   float64
+	activeInstancesCountMu sync.RWMutex
+)
+
 // Interface guards.
 var (
-	_ gotenberg.Module      = (*PDFtk)(nil)
-	_ gotenberg.Provisioner = (*PDFtk)(nil)
-	_ gotenberg.Validator   = (*PDFtk)(nil)
-	_ gotenberg.PDFEngine   = (*PDFtk)(nil)
+	_ gotenberg.Module          = (*PDFtk)(nil)
+	_ gotenberg.Provisioner     = (*PDFtk)(nil)
+	_ gotenberg.Validator       = (*PDFtk)(nil)
+	_ gotenberg.MetricsProvider = (*PDFtk)(nil)
+	_ gotenberg.PDFEngine       = (*PDFtk)(nil)
 )

pkg/modules/pdftk/pdftk_test.go

@@ -62,6 +62,22 @@ func TestPDFtk_Validate(t *testing.T) {
 	}
 }
 
+func TestPDFtk_Metrics(t *testing.T) {
+	metrics, err := new(PDFtk).Metrics()
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	if len(metrics) != 1 {
+		t.Errorf("expected %d metrics, but got %d", 1, len(metrics))
+	}
+
+	actual := metrics[0].Read()
+	if actual != 0 {
+		t.Errorf("expected %d PDFtk instances, but got %f", 0, actual)
+	}
+}
+
 func TestPDFtk_Merge(t *testing.T) {
 	for i, tc := range []struct {
 		ctx        context.Context

pkg/modules/prometheus/doc.go

@@ -0,0 +1,3 @@
+// Package prometheus provides a module which collects metrics and exposes them
+// via an HTTP route.
+package prometheus

pkg/modules/prometheus/prometheus.go

@@ -0,0 +1,189 @@
+package prometheus
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	flag "github.com/spf13/pflag"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(Prometheus{})
+}
+
+// Prometheus is a module which collects metrics and exposes them via an HTTP
+// route.
+type Prometheus struct {
+	namespace           string
+	interval            time.Duration
+	disableRouteLogging bool
+	disableCollect      bool
+
+	metrics  []gotenberg.Metric
+	registry *prometheus.Registry
+}
+
+// Descriptor returns a Prometheus's module descriptor.
+func (Prometheus) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "prometheus",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("prometheus", flag.ExitOnError)
+			fs.String("prometheus-namespace", "gotenberg", "Set the namespace of modules' metrics")
+			fs.Duration("prometheus-collect-interval", time.Duration(1)*time.Second, "Set the interval for collecting modules' metrics")
+			fs.Bool("prometheus-disable-route-logging", false, "Disable the route logging")
+			fs.Bool("prometheus-disable-collect", false, "Disable the collect of metrics")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(Prometheus) },
+	}
+}
+
+// Provision sets the modules properties.
+func (mod *Prometheus) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	mod.namespace = flags.MustString("prometheus-namespace")
+	mod.interval = flags.MustDuration("prometheus-collect-interval")
+	mod.disableRouteLogging = flags.MustBool("prometheus-disable-route-logging")
+	mod.disableCollect = flags.MustBool("prometheus-disable-collect")
+
+	if mod.disableCollect {
+		// Exit early.
+		return nil
+	}
+
+	// Get metrics from modules.
+	mods, err := ctx.Modules(new(gotenberg.MetricsProvider))
+	if err != nil {
+		return fmt.Errorf("get metrics providers: %w", err)
+	}
+
+	metricsProviders := make([]gotenberg.MetricsProvider, len(mods))
+	for i, metricsProvider := range mods {
+		metricsProviders[i] = metricsProvider.(gotenberg.MetricsProvider)
+	}
+
+	for _, metricsProvider := range metricsProviders {
+		metrics, err := metricsProvider.Metrics()
+		if err != nil {
+			return fmt.Errorf("get metrics: %w", err)
+		}
+
+		mod.metrics = append(mod.metrics, metrics...)
+	}
+
+	mod.registry = prometheus.NewRegistry()
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (mod Prometheus) Validate() error {
+	if mod.disableCollect {
+		// Exit early.
+		return nil
+	}
+
+	if mod.namespace == "" {
+		return errors.New("namespace must not be empty")
+	}
+
+	metricsMap := make(map[string]string, len(mod.metrics))
+
+	for _, metric := range mod.metrics {
+		if metric.Name == "" {
+			return errors.New("metric name cannot be empty")
+		}
+
+		if metric.Read == nil {
+			return fmt.Errorf("metric '%s' has nil read method", metric.Name)
+		}
+
+		if _, ok := metricsMap[metric.Name]; ok {
+			return fmt.Errorf("metric '%s' is already registered", metric.Name)
+		}
+
+		metricsMap[metric.Name] = metric.Name
+	}
+
+	return nil
+}
+
+// Start starts the collect.
+func (mod Prometheus) Start() error {
+	if mod.disableCollect {
+		// Exit early.
+		return nil
+	}
+
+	for _, metric := range mod.metrics {
+		gauge := prometheus.NewGauge(
+			prometheus.GaugeOpts{
+				Namespace: mod.namespace,
+				Name:      metric.Name,
+				Help:      metric.Description,
+			},
+		)
+
+		mod.registry.MustRegister(gauge)
+
+		go func(gauge prometheus.Gauge, metric gotenberg.Metric) {
+			for {
+				gauge.Set(metric.Read())
+				time.Sleep(mod.interval)
+			}
+		}(gauge, metric)
+	}
+
+	return nil
+}
+
+// StartupMessage returns a custom startup message.
+func (mod Prometheus) StartupMessage() string {
+	if mod.disableCollect {
+		return "application not started (collect disabled by user)"
+	}
+
+	return "collecting metrics"
+}
+
+// Stop does nothing.
+func (mod Prometheus) Stop(_ context.Context) error {
+	return nil
+}
+
+// Routes returns the HTTP route.
+func (mod Prometheus) Routes() ([]api.Route, error) {
+	if mod.disableCollect {
+		return nil, nil
+	}
+
+	return []api.Route{
+		{
+			Method:         http.MethodGet,
+			Path:           "/prometheus/metrics",
+			DisableLogging: mod.disableRouteLogging,
+			Handler: echo.WrapHandler(
+				promhttp.HandlerFor(mod.registry, promhttp.HandlerOpts{}),
+			),
+		},
+	}, nil
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module      = (*Prometheus)(nil)
+	_ gotenberg.Provisioner = (*Prometheus)(nil)
+	_ gotenberg.Validator   = (*Prometheus)(nil)
+	_ gotenberg.App         = (*Prometheus)(nil)
+	_ api.Router            = (*Prometheus)(nil)
+)

pkg/modules/prometheus/prometheus_test.go

@@ -0,0 +1,360 @@
+package prometheus
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type ProtoModule struct {
+	descriptor func() gotenberg.ModuleDescriptor
+}
+
+func (mod ProtoModule) Descriptor() gotenberg.ModuleDescriptor {
+	return mod.descriptor()
+}
+
+type ProtoValidator struct {
+	ProtoModule
+	validate func() error
+}
+
+func (mod ProtoValidator) Validate() error {
+	return mod.validate()
+}
+
+type ProtoMetricsProvider struct {
+	ProtoValidator
+	metrics func() ([]gotenberg.Metric, error)
+}
+
+func (mod ProtoMetricsProvider) Metrics() ([]gotenberg.Metric, error) {
+	return mod.metrics()
+}
+
+func TestPrometheus_Descriptor(t *testing.T) {
+	descriptor := Prometheus{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Prometheus))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestPrometheus_Provision(t *testing.T) {
+	for i, tc := range []struct {
+		ctx           *gotenberg.Context
+		expectMetrics []gotenberg.Metric
+		expectErr     bool
+	}{
+		{
+			ctx: func() *gotenberg.Context {
+				fs := new(Prometheus).Descriptor().FlagSet
+				err := fs.Parse([]string{"--prometheus-disable-collect=true"})
+
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMetricsProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return errors.New("foo")
+				}
+				mod.metrics = func() ([]gotenberg.Metric, error) {
+					return nil, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Prometheus).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMetricsProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.metrics = func() ([]gotenberg.Metric, error) {
+					return nil, errors.New("foo")
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Prometheus).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectErr: true,
+		},
+		{
+			ctx: func() *gotenberg.Context {
+				mod := struct{ ProtoMetricsProvider }{}
+				mod.descriptor = func() gotenberg.ModuleDescriptor {
+					return gotenberg.ModuleDescriptor{ID: "foo", New: func() gotenberg.Module { return mod }}
+				}
+				mod.validate = func() error {
+					return nil
+				}
+				mod.metrics = func() ([]gotenberg.Metric, error) {
+					return []gotenberg.Metric{
+						{
+							Name:        "foo",
+							Description: "Bar.",
+						},
+					}, nil
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: new(Prometheus).Descriptor().FlagSet,
+					},
+					[]gotenberg.ModuleDescriptor{
+						mod.Descriptor(),
+					},
+				)
+			}(),
+			expectMetrics: []gotenberg.Metric{
+				{
+					Name:        "foo",
+					Description: "Bar.",
+				},
+			},
+		},
+	} {
+		mod := new(Prometheus)
+		err := mod.Provision(tc.ctx)
+
+		if !reflect.DeepEqual(mod.metrics, tc.expectMetrics) {
+			t.Errorf("test %d: expected %+v, but got: %+v", i, tc.expectMetrics, mod.metrics)
+		}
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestPrometheus_Validate(t *testing.T) {
+	for i, tc := range []struct {
+		namespace      string
+		metrics        []gotenberg.Metric
+		disableCollect bool
+		expectErr      bool
+	}{
+		{
+			disableCollect: true,
+		},
+		{
+			namespace: "",
+			expectErr: true,
+		},
+		{
+			namespace: "foo",
+			metrics: []gotenberg.Metric{
+				{
+					Name: "",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			namespace: "foo",
+			metrics: []gotenberg.Metric{
+				{
+					Name: "foo",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			namespace: "foo",
+			metrics: []gotenberg.Metric{
+				{
+					Name: "foo",
+					Read: func() float64 {
+						return 0
+					},
+				},
+				{
+					Name: "foo",
+					Read: func() float64 {
+						return 0
+					},
+				},
+			},
+			expectErr: true,
+		},
+		{
+			namespace: "foo",
+			metrics: []gotenberg.Metric{
+				{
+					Name: "foo",
+					Read: func() float64 {
+						return 0
+					},
+				},
+				{
+					Name: "bar",
+					Read: func() float64 {
+						return 0
+					},
+				},
+			},
+		},
+	} {
+		mod := Prometheus{
+			namespace:      tc.namespace,
+			metrics:        tc.metrics,
+			disableCollect: tc.disableCollect,
+		}
+
+		err := mod.Validate()
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestPrometheus_Start(t *testing.T) {
+	for i, tc := range []struct {
+		metrics        []gotenberg.Metric
+		disableCollect bool
+	}{
+		{
+			disableCollect: true,
+		},
+		{
+			metrics: []gotenberg.Metric{
+				{
+					Name: "foo",
+					Read: func() float64 {
+						return 0
+					},
+				},
+			},
+		},
+	} {
+		mod := Prometheus{
+			namespace:      "foo",
+			interval:       time.Duration(1) * time.Second,
+			metrics:        tc.metrics,
+			disableCollect: tc.disableCollect,
+			registry:       prometheus.NewRegistry(),
+		}
+
+		err := mod.Start()
+		if err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+	}
+}
+
+func TestPrometheus_StartupMessage(t *testing.T) {
+	for i, tc := range []struct {
+		disableCollect bool
+		expectMessage  string
+	}{
+		{
+			expectMessage:  "application not started (collect disabled by user)",
+			disableCollect: true,
+		},
+		{
+			expectMessage: "collecting metrics",
+		},
+	} {
+		mod := Prometheus{
+			disableCollect: tc.disableCollect,
+		}
+
+		actual := mod.StartupMessage()
+		if actual != tc.expectMessage {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectMessage, actual)
+		}
+	}
+}
+
+func TestPrometheus_Stop(t *testing.T) {
+	err := Prometheus{}.Stop(nil)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestPrometheus_Routes(t *testing.T) {
+	for i, tc := range []struct {
+		expectRoutes   int
+		disableCollect bool
+	}{
+		{
+			disableCollect: true,
+		},
+		{
+			expectRoutes: 1,
+		},
+	} {
+		mod := Prometheus{
+			disableCollect: tc.disableCollect,
+			registry:       prometheus.NewRegistry(),
+		}
+
+		routes, err := mod.Routes()
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		if tc.expectRoutes != len(routes) {
+			t.Errorf("test %d: expected %d routes but got %d", i, tc.expectRoutes, len(routes))
+		}
+	}
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module          = (*ProtoModule)(nil)
+	_ gotenberg.Validator       = (*ProtoValidator)(nil)
+	_ gotenberg.Module          = (*ProtoValidator)(nil)
+	_ gotenberg.MetricsProvider = (*ProtoMetricsProvider)(nil)
+	_ gotenberg.Module          = (*ProtoMetricsProvider)(nil)
+	_ gotenberg.Validator       = (*ProtoMetricsProvider)(nil)
+)

pkg/modules/webhook/client.go

@@ -1,4 +1,4 @@
-package api
+package webhook
 
 import (
 	"fmt"
@@ -11,8 +11,8 @@ import (
 	"go.uber.org/zap"
 )
 
-// webhookClient gathers all the data required to send a request to a webhook.
-type webhookClient struct {
+// client gathers all the data required to send a request to a webhook.
+type client struct {
 	url              string
 	method           string
 	errorURL         string
@@ -25,15 +25,15 @@ type webhookClient struct {
 }
 
 // send call the webhook either to send the success response or the error response.
-func (webhook webhookClient) send(body io.Reader, headers map[string]string, erroed bool) error {
-	URL := webhook.url
+func (c client) send(body io.Reader, headers map[string]string, erroed bool) error {
+	URL := c.url
 	if erroed {
-		URL = webhook.errorURL
+		URL = c.errorURL
 	}
 
-	method := webhook.method
+	method := c.method
 	if erroed {
-		method = webhook.errorMethod
+		method = c.errorMethod
 	}
 
 	req, err := retryablehttp.NewRequest(method, URL, body)
@@ -44,7 +44,7 @@ func (webhook webhookClient) send(body io.Reader, headers map[string]string, err
 	req.Header.Set("User-Agent", "Gotenberg")
 
 	// Extra HTTP headers are the custom headers from the user.
-	for key, value := range webhook.extraHTTPHeaders {
+	for key, value := range c.extraHTTPHeaders {
 		req.Header.Set(key, value)
 	}
 
@@ -73,7 +73,7 @@ func (webhook webhookClient) send(body io.Reader, headers map[string]string, err
 		req.Header.Set(key, value)
 	}
 
-	resp, err := webhook.client.Do(req)
+	resp, err := c.client.Do(req)
 	if err != nil {
 		return fmt.Errorf("send '%s' request to '%s': %w", method, URL, err)
 	}
@@ -81,7 +81,7 @@ func (webhook webhookClient) send(body io.Reader, headers map[string]string, err
 	defer func() {
 		err := resp.Body.Close()
 		if err != nil {
-			webhook.logger.Error(fmt.Sprintf("close response body from '%s': %s", URL, err))
+			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", URL, err))
 		}
 	}()
 
@@ -92,17 +92,17 @@ func (webhook webhookClient) send(body io.Reader, headers map[string]string, err
 	fields := make([]zap.Field, 5)
 	fields[0] = zap.String("webhook_url", URL)
 	fields[1] = zap.String("method", method)
-	fields[2] = zap.Int64("latency", int64(finishTime.Sub(webhook.startTime)))
-	fields[3] = zap.String("latency_human", finishTime.Sub(webhook.startTime).String())
+	fields[2] = zap.Int64("latency", int64(finishTime.Sub(c.startTime)))
+	fields[3] = zap.String("latency_human", finishTime.Sub(c.startTime).String())
 	fields[4] = zap.Int64("bytes_out", req.ContentLength)
 
 	if erroed {
-		webhook.logger.Warn("request to webhook with error details handled", fields...)
+		c.logger.Warn("request to webhook with error details handled", fields...)
 
 		return nil
 	}
 
-	webhook.logger.Info("request to webhook handled", fields...)
+	c.logger.Info("request to webhook handled", fields...)
 
 	return nil
 }

pkg/modules/webhook/client_test.go

@@ -1,4 +1,4 @@
-package api
+package webhook
 
 import (
 	"testing"

pkg/modules/webhook/doc.go

@@ -0,0 +1,3 @@
+// Package webhook provides a module which adds a middleware for uploading
+// output files to any destinations in an asynchronous fashion.
+package webhook

pkg/modules/webhook/middleware.go

@@ -0,0 +1,278 @@
+package webhook
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/labstack/echo/v4"
+)
+
+func webhookMiddleware(w Webhook) api.Middleware {
+	return api.Middleware{
+		Stack: api.MultipartStack,
+		Handler: func() echo.MiddlewareFunc {
+			return func(next echo.HandlerFunc) echo.HandlerFunc {
+				return func(c echo.Context) error {
+					webhookURL := c.Request().Header.Get("Gotenberg-Webhook-Url")
+
+					if webhookURL == "" {
+						// No webhook URL, call the next middleware in the chain.
+						return next(c)
+					}
+
+					ctx := c.Get("context").(*api.Context)
+					cancel := c.Get("cancel").(context.CancelFunc)
+
+					// Do we have a webhook error URL in case of... error?
+					webhookErrorURL := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
+
+					if webhookErrorURL == "" {
+						return api.WrapError(
+							errors.New("empty webhook error URL"),
+							api.NewSentinelHTTPError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
+						)
+					}
+
+					// Let's check if the webhook URLs are acceptable according to our
+					// allowed/denied lists.
+					filter := func(URL, header string, allowList, denyList *regexp.Regexp) error {
+						if !allowList.MatchString(URL) {
+							return api.WrapError(
+								fmt.Errorf("'%s' does not match the expression from the allowed list", URL),
+								api.NewSentinelHTTPError(
+									http.StatusForbidden,
+									fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
+								),
+							)
+						}
+
+						if denyList.String() != "" && denyList.MatchString(URL) {
+							return api.WrapError(
+								fmt.Errorf("'%s' matches the expression from the denied list", URL),
+								api.NewSentinelHTTPError(
+									http.StatusForbidden,
+									fmt.Sprintf("Invalid '%s' header value: '%s' does not match the authorized URLs", header, URL),
+								),
+							)
+						}
+
+						return nil
+					}
+
+					err := filter(webhookURL, "Gotenberg-Webhook-Url", w.allowList, w.denyList)
+					if err != nil {
+						return fmt.Errorf("filter webhook URL: %w", err)
+					}
+
+					err = filter(webhookErrorURL, "Gotenberg-Webhook-Error-Url", w.errorAllowList, w.errorDenyList)
+					if err != nil {
+						return fmt.Errorf("filter webhook error URL: %w", err)
+					}
+
+					// Let's check the HTTP methods for calling the webhook URLs.
+					methodFromHeader := func(header string) (string, error) {
+						method := c.Request().Header.Get(header)
+
+						if method == "" {
+							return http.MethodPost, nil
+						}
+
+						method = strings.ToUpper(method)
+
+						switch method {
+						case http.MethodPost:
+							return method, nil
+						case http.MethodPatch:
+							return method, nil
+						case http.MethodPut:
+							return method, nil
+						}
+
+						return "", api.WrapError(
+							fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
+							api.NewSentinelHTTPError(
+								http.StatusBadRequest,
+								fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method),
+							),
+						)
+					}
+
+					webhookMethod, err := methodFromHeader("Gotenberg-Webhook-Method")
+					if err != nil {
+						return fmt.Errorf("get method to use for webhook: %w", err)
+					}
+
+					webhookErrorMethod, err := methodFromHeader("Gotenberg-Webhook-Error-Method")
+					if err != nil {
+						return fmt.Errorf("get method to use for webhook error: %w", err)
+					}
+
+					// What about extra HTTP headers?
+					var extraHTTPHeaders map[string]string
+
+					extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
+					if extraHTTPHeadersJSON != "" {
+						err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
+						if err != nil {
+							return api.WrapError(
+								fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
+								api.NewSentinelHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
+							)
+						}
+					}
+
+					client := &client{
+						url:              webhookURL,
+						method:           webhookMethod,
+						errorURL:         webhookErrorURL,
+						errorMethod:      webhookErrorMethod,
+						extraHTTPHeaders: extraHTTPHeaders,
+						startTime:        c.Get("startTime").(time.Time),
+
+						client: &retryablehttp.Client{
+							HTTPClient: &http.Client{
+								Timeout: c.Get("writeTimeout").(time.Duration),
+							},
+							RetryMax:     w.maxRetry,
+							RetryWaitMin: w.retryMinWait,
+							RetryWaitMax: w.retryMaxWait,
+							Logger: leveledLogger{
+								logger: ctx.Log(),
+							},
+							CheckRetry: retryablehttp.DefaultRetryPolicy,
+							Backoff:    retryablehttp.DefaultBackoff,
+						},
+						logger: ctx.Log(),
+					}
+
+					// This method parses an "asynchronous" error and sends a
+					// request to the webhook error URL with a JSON body
+					// containing the status and the error message.
+					handleAsyncError := func(err error) {
+						status, message := api.ParseError(err)
+
+						body := struct {
+							Status  int    `json:"status"`
+							Message string `json:"message"`
+						}{
+							Status:  status,
+							Message: message,
+						}
+
+						b, err := json.Marshal(body)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("marshal JSON: %s", err.Error()))
+
+							return
+						}
+
+						headers := map[string]string{
+							echo.HeaderContentType:        echo.MIMEApplicationJSONCharsetUTF8,
+							c.Get("traceHeader").(string): c.Get("trace").(string),
+						}
+
+						err = client.send(bytes.NewReader(b), headers, true)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
+						}
+					}
+
+					// As a webhook URL has been given, we handle the request in a
+					// goroutine and return immediately.
+					go func() {
+						defer cancel()
+
+						// Call the next middleware in the chain.
+						err := next(c)
+
+						if err != nil {
+							// The process failed for whatever reason. Let's send the
+							// details to the webhook.
+							ctx.Log().Error(err.Error())
+							handleAsyncError(err)
+
+							return
+						}
+
+						// No error, let's get build the output file.
+						outputPath, err := ctx.BuildOutputFile()
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
+							handleAsyncError(err)
+
+							return
+						}
+
+						outputFile, err := os.Open(outputPath)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("open output file: %s", err))
+							handleAsyncError(err)
+
+							return
+						}
+
+						defer func() {
+							err := outputFile.Close()
+							if err != nil {
+								ctx.Log().Error(fmt.Sprintf("close output file: %s", err))
+							}
+						}()
+
+						fileHeader := make([]byte, 512)
+						_, err = outputFile.Read(fileHeader)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("read header of output file: %s", err))
+							handleAsyncError(err)
+
+							return
+						}
+
+						fileStat, err := outputFile.Stat()
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("get stat from output file: %s", err))
+							handleAsyncError(err)
+
+							return
+						}
+
+						_, err = outputFile.Seek(0, 0)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("reset output file reader: %s", err))
+							handleAsyncError(err)
+
+							return
+						}
+
+						headers := map[string]string{
+							echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", ctx.OutputFilename(outputPath)),
+							echo.HeaderContentType:        http.DetectContentType(fileHeader),
+							echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
+							c.Get("traceHeader").(string): c.Get("trace").(string),
+						}
+
+						// Send the output file to the webhook.
+						err = client.send(bufio.NewReader(outputFile), headers, false)
+						if err != nil {
+							ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
+							handleAsyncError(err)
+						}
+					}()
+
+					return api.ErrAsyncProcess
+				}
+			}
+		}(),
+	}
+}

pkg/modules/webhook/middleware_test.go

@@ -0,0 +1,534 @@
+package webhook
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	"github.com/labstack/echo/v4"
+	"go.uber.org/zap"
+)
+
+func TestWebhookMiddlewareGuards(t *testing.T) {
+	buildMultipartFormDataRequest := func() *http.Request {
+		body := &bytes.Buffer{}
+		writer := multipart.NewWriter(body)
+
+		defer func() {
+			err := writer.Close()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		}()
+
+		err := writer.WriteField("foo", "foo")
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		req := httptest.NewRequest(http.MethodPost, "/", body)
+		req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+
+		return req
+	}
+
+	buildWebhookModule := func() Webhook {
+		return Webhook{
+			allowList:      regexp.MustCompile(""),
+			denyList:       regexp.MustCompile(""),
+			errorAllowList: regexp.MustCompile(""),
+			errorDenyList:  regexp.MustCompile(""),
+			maxRetry:       0,
+			retryMinWait:   0,
+			retryMaxWait:   0,
+			disable:        false,
+		}
+	}
+
+	for i, tc := range []struct {
+		request          *http.Request
+		mod              Webhook
+		next             echo.HandlerFunc
+		expectErr        bool
+		expectHTTPErr    bool
+		expectHTTPStatus int
+	}{
+		{
+			request: buildMultipartFormDataRequest(),
+			mod:     buildWebhookModule(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return nil
+				}
+			}(),
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+
+				return req
+			}(),
+			mod: func() Webhook {
+				mod := buildWebhookModule()
+				mod.allowList = regexp.MustCompile("bar")
+
+				return mod
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusForbidden,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+
+				return req
+			}(),
+			mod: func() Webhook {
+				mod := buildWebhookModule()
+				mod.denyList = regexp.MustCompile("foo")
+
+				return mod
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusForbidden,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+
+				return req
+			}(),
+			mod: func() Webhook {
+				mod := buildWebhookModule()
+				mod.errorAllowList = regexp.MustCompile("foo")
+
+				return mod
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusForbidden,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+
+				return req
+			}(),
+			mod: func() Webhook {
+				mod := buildWebhookModule()
+				mod.errorDenyList = regexp.MustCompile("bar")
+
+				return mod
+			}(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusForbidden,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Method", http.MethodGet)
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPost)
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPatch)
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Method", http.MethodPut)
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				req.Header.Set("Gotenberg-Webhook-Error-Method", http.MethodGet)
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Webhook-Url", "foo")
+				req.Header.Set("Gotenberg-Webhook-Error-Url", "bar")
+				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", "foo")
+
+				return req
+			}(),
+			mod:              buildWebhookModule(),
+			expectErr:        true,
+			expectHTTPErr:    true,
+			expectHTTPStatus: http.StatusBadRequest,
+		},
+	} {
+		srv := echo.New()
+		srv.HideBanner = true
+		srv.HidePort = true
+
+		c := srv.NewContext(tc.request, httptest.NewRecorder())
+
+		ctx := &api.MockContext{Context: &api.Context{}}
+		ctx.SetEchoContext(c)
+
+		c.Set("context", ctx.Context)
+		c.Set("cancel", func() context.CancelFunc {
+			return func() {
+				return
+			}
+		}())
+
+		err := webhookMiddleware(tc.mod).Handler(tc.next)(c)
+
+		if tc.expectErr && err == nil {
+			t.Errorf("test %d: expected error but got: %v", i, err)
+		}
+
+		if !tc.expectErr && err != nil {
+			t.Errorf("test %d: expected no error but got: %v", i, err)
+		}
+
+		var httpErr api.HTTPError
+		isHTTPErr := errors.As(err, &httpErr)
+
+		if tc.expectHTTPErr && !isHTTPErr {
+			t.Errorf("test %d: expected HTTP error but got: %v", i, err)
+		}
+
+		if !tc.expectHTTPErr && isHTTPErr {
+			t.Errorf("test %d: expected no HTTP error but got one: %v", i, httpErr)
+		}
+
+		if err != nil && tc.expectHTTPErr && isHTTPErr {
+			status, _ := httpErr.HTTPError()
+			if status != tc.expectHTTPStatus {
+				t.Errorf("test %d: expected %d HTTP status code but got %d", i, tc.expectHTTPStatus, status)
+			}
+		}
+	}
+}
+
+func TestWebhookMiddlewareAsynchronousProcess(t *testing.T) {
+	buildMultipartFormDataRequest := func() *http.Request {
+		body := &bytes.Buffer{}
+		writer := multipart.NewWriter(body)
+
+		defer func() {
+			err := writer.Close()
+			if err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		}()
+
+		err := writer.WriteField("foo", "foo")
+		if err != nil {
+			t.Fatalf("expected no error but got: %v", err)
+		}
+
+		req := httptest.NewRequest(http.MethodPost, "/", body)
+		req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+
+		return req
+	}
+
+	buildWebhookModule := func() Webhook {
+		return Webhook{
+			allowList:      regexp.MustCompile(""),
+			denyList:       regexp.MustCompile(""),
+			errorAllowList: regexp.MustCompile(""),
+			errorDenyList:  regexp.MustCompile(""),
+			maxRetry:       0,
+			retryMinWait:   0,
+			retryMaxWait:   0,
+			disable:        false,
+		}
+	}
+
+	for i, tc := range []struct {
+		request                       *http.Request
+		mod                           Webhook
+		next                          echo.HandlerFunc
+		expectWebhookContentType      string
+		expectWebhookMethod           string
+		expectWebhookExtraHTTPHeaders map[string]string
+		expectWebhookFilename         string
+		expectWebhookErrorStatus      int
+		expectWebhookErrorMessage     string
+	}{
+		{
+			request: buildMultipartFormDataRequest(),
+			mod:     buildWebhookModule(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return errors.New("foo")
+				}
+			}(),
+			expectWebhookContentType:  echo.MIMEApplicationJSONCharsetUTF8,
+			expectWebhookMethod:       http.MethodPost,
+			expectWebhookErrorStatus:  http.StatusInternalServerError,
+			expectWebhookErrorMessage: http.StatusText(http.StatusInternalServerError),
+		},
+		{
+			request: buildMultipartFormDataRequest(),
+			mod:     buildWebhookModule(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					return nil
+				}
+			}(),
+			expectWebhookContentType:  echo.MIMEApplicationJSONCharsetUTF8,
+			expectWebhookMethod:       http.MethodPost,
+			expectWebhookErrorStatus:  http.StatusInternalServerError,
+			expectWebhookErrorMessage: http.StatusText(http.StatusInternalServerError),
+		},
+		{
+			request: func() *http.Request {
+				req := buildMultipartFormDataRequest()
+				req.Header.Set("Gotenberg-Output-Filename", "foo")
+				req.Header.Set("Gotenberg-Webhook-Extra-Http-Headers", `{ "foo": "bar" }`)
+
+				return req
+			}(),
+			mod: buildWebhookModule(),
+			next: func() echo.HandlerFunc {
+				return func(c echo.Context) error {
+					ctx := c.Get("context").(*api.Context)
+
+					return ctx.AddOutputPaths("/tests/test/testdata/api/sample2.pdf")
+				}
+			}(),
+			expectWebhookContentType:      "application/pdf",
+			expectWebhookMethod:           http.MethodPost,
+			expectWebhookFilename:         "foo",
+			expectWebhookExtraHTTPHeaders: map[string]string{"foo": "bar"},
+		},
+	} {
+		func() {
+			srv := echo.New()
+			srv.HideBanner = true
+			srv.HidePort = true
+
+			c := srv.NewContext(tc.request, httptest.NewRecorder())
+			c.Set("logger", zap.NewNop())
+			c.Set("traceHeader", "Gotenberg-Trace")
+			c.Set("trace", "foo")
+			c.Set("startTime", time.Now())
+			c.Set("writeTimeout", time.Duration(10)*time.Second)
+
+			ctx := &api.MockContext{Context: &api.Context{}}
+			ctx.SetLogger(zap.NewNop())
+			ctx.SetEchoContext(c)
+
+			c.Set("context", ctx.Context)
+			c.Set("cancel", func() context.CancelFunc {
+				return func() {
+					return
+				}
+			}())
+
+			webhook := echo.New()
+			webhook.HideBanner = true
+			webhook.HidePort = true
+
+			rand.Seed(time.Now().UnixNano())
+			webhookPort := rand.Intn(65535-1025+1) + 1025
+
+			c.Request().Header.Set("Gotenberg-Webhook-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
+			c.Request().Header.Set("Gotenberg-Webhook-Error-Url", fmt.Sprintf("http://localhost:%d/", webhookPort))
+
+			errChan := make(chan error, 1)
+
+			webhook.POST(
+				"/",
+				func() echo.HandlerFunc {
+					return func(c echo.Context) error {
+						contentType := c.Request().Header.Get(echo.HeaderContentType)
+						if contentType != tc.expectWebhookContentType {
+							t.Errorf("test %d: expected '%s' '%s' but got '%s'", i, echo.HeaderContentType, tc.expectWebhookContentType, contentType)
+						}
+
+						trace := c.Request().Header.Get("Gotenberg-Trace")
+						if trace != "foo" {
+							t.Errorf("test %d: expected '%s' '%s' but got '%s'", i, "Gotenberg-Trace", "foo", trace)
+						}
+
+						method := c.Request().Method
+						if method != tc.expectWebhookMethod {
+							t.Errorf("test %d: expected HTTP method '%s' but got '%s'", i, tc.expectWebhookMethod, method)
+						}
+
+						for key, expect := range tc.expectWebhookExtraHTTPHeaders {
+							actual := c.Request().Header.Get(key)
+
+							if actual != expect {
+								t.Errorf("test %d: expected '%s' '%s' but got '%s'", i, key, expect, actual)
+							}
+						}
+
+						if contentType == echo.MIMEApplicationJSONCharsetUTF8 {
+							body, err := ioutil.ReadAll(c.Request().Body)
+							if err != nil {
+								errChan <- err
+								return nil
+							}
+
+							result := struct {
+								Status  int    `json:"status"`
+								Message string `json:"message"`
+							}{}
+
+							err = json.Unmarshal(body, &result)
+							if err != nil {
+								errChan <- err
+								return nil
+							}
+
+							if result.Status != tc.expectWebhookErrorStatus {
+								t.Errorf("test %d: expected status %d from JSON but got %d", i, tc.expectWebhookErrorStatus, result.Status)
+							}
+
+							if result.Message != tc.expectWebhookErrorMessage {
+								t.Errorf("test %d: expected message '%s' from JSON but got '%s'", i, tc.expectWebhookErrorMessage, result.Message)
+							}
+
+							errChan <- nil
+							return nil
+						}
+
+						contentLength := c.Request().Header.Get(echo.HeaderContentLength)
+						if contentLength == "" {
+							t.Errorf("test %d: expected non empty '%s'", i, echo.HeaderContentLength)
+						}
+
+						contentDisposition := c.Request().Header.Get(echo.HeaderContentDisposition)
+						if !strings.Contains(contentDisposition, tc.expectWebhookFilename) {
+							t.Errorf("test %d: expected '%s' '%s' to contain '%s'", i, echo.HeaderContentDisposition, contentDisposition, tc.expectWebhookFilename)
+						}
+
+						body, err := ioutil.ReadAll(c.Request().Body)
+						if err != nil {
+							errChan <- err
+							return nil
+						}
+
+						if body == nil || len(body) == 0 {
+							t.Errorf("test %d: expected non nil body", i)
+						}
+
+						errChan <- nil
+						return nil
+					}
+				}(),
+			)
+
+			go func() {
+				err := webhook.Start(fmt.Sprintf(":%d", webhookPort))
+				if !errors.Is(err, http.ErrServerClosed) {
+					t.Errorf("test %d: expected no error but got: %v", i, err)
+				}
+			}()
+
+			defer func() {
+				err := webhook.Shutdown(context.TODO())
+				if err != nil {
+					t.Errorf("test %d: expected no error but got: %v", i, err)
+				}
+			}()
+
+			err := webhookMiddleware(tc.mod).Handler(tc.next)(c)
+			if err != nil && err != api.ErrAsyncProcess {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+
+			err = <-errChan
+			if err != nil {
+				t.Errorf("test %d: expected no error but got: %v", i, err)
+			}
+		}()
+	}
+
+}

pkg/modules/webhook/webhook.go

@@ -0,0 +1,126 @@
+package webhook
+
+import (
+	"fmt"
+	"regexp"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+	"github.com/gotenberg/gotenberg/v7/pkg/modules/api"
+	flag "github.com/spf13/pflag"
+	"go.uber.org/multierr"
+)
+
+func init() {
+	gotenberg.MustRegisterModule(Webhook{})
+}
+
+// Webhook is a module which provides a middleware for uploading output files
+// to any destinations in an asynchronous fashion.
+type Webhook struct {
+	allowList      *regexp.Regexp
+	denyList       *regexp.Regexp
+	errorAllowList *regexp.Regexp
+	errorDenyList  *regexp.Regexp
+	maxRetry       int
+	retryMinWait   time.Duration
+	retryMaxWait   time.Duration
+	disable        bool
+}
+
+// Descriptor returns an Webhook's module descriptor.
+func (Webhook) Descriptor() gotenberg.ModuleDescriptor {
+	return gotenberg.ModuleDescriptor{
+		ID: "webhook",
+		FlagSet: func() *flag.FlagSet {
+			fs := flag.NewFlagSet("webhook", flag.ExitOnError)
+			// Deprecated flags.
+			fs.String("api-webhook-allow-list", "", "Set the allowed URLs for the webhook feature using a regular expression")
+			fs.String("api-webhook-deny-list", "", "Set the denied URLs for the webhook feature using a regular expression")
+			fs.String("api-webhook-error-allow-list", "", "Set the allowed URLs in case of an error for the webhook feature using a regular expression")
+			fs.String("api-webhook-error-deny-list", "", "Set the denied URLs in case of an error for the webhook feature using a regular expression")
+			fs.Int("api-webhook-max-retry", 4, "Set the maximum number of retries for the webhook feature")
+			fs.Duration("api-webhook-retry-min-wait", time.Duration(1)*time.Second, "Set the minimum duration to wait before trying to call the webhook again")
+			fs.Duration("api-webhook-retry-max-wait", time.Duration(30)*time.Second, "Set the maximum duration to wait before trying to call the webhook again")
+			fs.Bool("api-disable-webhook", false, "Disable the webhook feature")
+
+			var err error
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-allow-list", "use webhook-allow-list instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-deny-list", "use webhook-deny-list instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-error-allow-list", "use webhook-error-allow-list instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-error-deny-list", "use webhook-error-deny-list instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-max-retry", "use webhook-max-retry instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-retry-min-wait", "use webhook-retry-min-wait instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-webhook-retry-max-wait", "use webhook-retry-max-wait instead"))
+			err = multierr.Append(err, fs.MarkDeprecated("api-disable-webhook", "use webhook-disable instead"))
+
+			if err != nil {
+				panic(fmt.Errorf("create deprecated flags for webhook module: %v", err))
+			}
+
+			// New flags.
+			fs.String("webhook-allow-list", "", "Set the allowed URLs for the webhook feature using a regular expression")
+			fs.String("webhook-deny-list", "", "Set the denied URLs for the webhook feature using a regular expression")
+			fs.String("webhook-error-allow-list", "", "Set the allowed URLs in case of an error for the webhook feature using a regular expression")
+			fs.String("webhook-error-deny-list", "", "Set the denied URLs in case of an error for the webhook feature using a regular expression")
+			fs.Int("webhook-max-retry", 4, "Set the maximum number of retries for the webhook feature")
+			fs.Duration("webhook-retry-min-wait", time.Duration(1)*time.Second, "Set the minimum duration to wait before trying to call the webhook again")
+			fs.Duration("webhook-retry-max-wait", time.Duration(30)*time.Second, "Set the maximum duration to wait before trying to call the webhook again")
+			fs.Bool("webhook-disable", false, "Disable the webhook feature")
+
+			return fs
+		}(),
+		New: func() gotenberg.Module { return new(Webhook) },
+	}
+}
+
+// Provision sets the module properties.
+func (w *Webhook) Provision(ctx *gotenberg.Context) error {
+	flags := ctx.ParsedFlags()
+	w.allowList = flags.MustDeprecatedRegexp("api-webhook-allow-list", "webhook-allow-list")
+	w.denyList = flags.MustDeprecatedRegexp("api-webhook-deny-list", "webhook-deny-list")
+	w.errorAllowList = flags.MustDeprecatedRegexp("api-webhook-error-allow-list", "webhook-error-allow-list")
+	w.errorDenyList = flags.MustDeprecatedRegexp("api-webhook-error-deny-list", "webhook-error-deny-list")
+	w.maxRetry = flags.MustDeprecatedInt("api-webhook-max-retry", "webhook-max-retry")
+	w.retryMinWait = flags.MustDeprecatedDuration("api-webhook-retry-min-wait", "webhook-retry-min-wait")
+	w.retryMaxWait = flags.MustDeprecatedDuration("api-webhook-retry-min-wait", "webhook-retry-max-wait")
+	w.disable = flags.MustDeprecatedBool("api-disable-webhook", "webhook-disable")
+
+	return nil
+}
+
+// Middlewares returns the middleware.
+func (w Webhook) Middlewares() ([]api.Middleware, error) {
+	if w.disable {
+		return nil, nil
+	}
+
+	return []api.Middleware{
+		webhookMiddleware(w),
+	}, nil
+}
+
+// AddGraceDuration increases the grace duration provided by the API for the
+// garbage collector.
+func (w Webhook) AddGraceDuration() time.Duration {
+	var duration time.Duration
+
+	if w.disable {
+		return duration
+	}
+
+	for i := 0; i < w.maxRetry; i++ {
+		// Yep... Golang does not allow int * time.Duration.
+		duration += w.retryMaxWait
+	}
+
+	return duration
+}
+
+// Interface guards.
+var (
+	_ gotenberg.Module                             = (*Webhook)(nil)
+	_ gotenberg.Provisioner                        = (*Webhook)(nil)
+	_ api.MiddlewareProvider                       = (*Webhook)(nil)
+	_ api.GarbageCollectorGraceDurationIncrementer = (*Webhook)(nil)
+)

pkg/modules/webhook/webhook_test.go

@@ -0,0 +1,89 @@
+package webhook
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/gotenberg/gotenberg/v7/pkg/gotenberg"
+)
+
+func TestWebhook_Descriptor(t *testing.T) {
+	descriptor := Webhook{}.Descriptor()
+
+	actual := reflect.TypeOf(descriptor.New())
+	expect := reflect.TypeOf(new(Webhook))
+
+	if actual != expect {
+		t.Errorf("expected '%s' but got '%s'", expect, actual)
+	}
+}
+
+func TestWebhook_Provision(t *testing.T) {
+	mod := new(Webhook)
+	ctx := gotenberg.NewContext(
+		gotenberg.ParsedFlags{
+			FlagSet: new(Webhook).Descriptor().FlagSet,
+		},
+		nil,
+	)
+
+	err := mod.Provision(ctx)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+}
+
+func TestWebhook_Middlewares(t *testing.T) {
+	for i, tc := range []struct {
+		expectMiddlewares int
+		disable           bool
+	}{
+		{
+			expectMiddlewares: 1,
+		},
+		{
+			disable: true,
+		},
+	} {
+		mod := new(Webhook)
+		mod.disable = tc.disable
+
+		middlewares, err := mod.Middlewares()
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		if tc.expectMiddlewares != len(middlewares) {
+			t.Errorf("test %d: expected %d middlewares but got %d", i, tc.expectMiddlewares, len(middlewares))
+		}
+	}
+}
+
+func TestWebhook_AddGraceDuration(t *testing.T) {
+	for i, tc := range []struct {
+		maxRetry       int
+		retryMaxWait   time.Duration
+		expectDuration time.Duration
+		disable        bool
+	}{
+		{
+			maxRetry:       3,
+			retryMaxWait:   time.Duration(1) * time.Second,
+			expectDuration: time.Duration(3) * time.Second,
+		},
+		{
+			disable: true,
+		},
+	} {
+		mod := new(Webhook)
+		mod.maxRetry = tc.maxRetry
+		mod.retryMaxWait = tc.retryMaxWait
+		mod.disable = tc.disable
+
+		actual := mod.AddGraceDuration()
+		if actual != tc.expectDuration {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectDuration, actual)
+		}
+	}
+}

pkg/standard/imports.go

@@ -1,6 +1,7 @@
 package standard
 
 import (
+	// Standard Gotenberg modules.
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/api"
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/chromium"
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/gc"
@@ -11,4 +12,6 @@ import (
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/pdfcpu"
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/pdfengines"
 	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/pdftk"
+	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/prometheus"
+	_ "github.com/gotenberg/gotenberg/v7/pkg/modules/webhook"
 )