feat(otel): add OpenTelemetry support

pkg/modules/api/api.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net"
 	"net/http"
 	"sort"
@@ -15,7 +16,6 @@ import (
 	"github.com/labstack/echo/v4"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
-	"go.uber.org/zap"
 	"golang.org/x/net/http2"
 	"golang.org/x/sync/errgroup"
 
@@ -29,20 +29,20 @@ func init() {
 // Api is a module that provides an HTTP server. Other modules may add routes,
 // middlewares or health checks.
 type Api struct {
-	port                      int
-	bindIp                    string
-	tlsCertFile               string
-	tlsKeyFile                string
-	startTimeout              time.Duration
-	bodyLimit                 int64
-	timeout                   time.Duration
-	rootPath                  string
-	traceHeader               string
-	basicAuthUsername         string
-	basicAuthPassword         string
-	downloadFromCfg           downloadFromConfig
-	disableHealthCheckLogging bool
-	enableDebugRoute          bool
+	port                             int
+	bindIp                           string
+	tlsCertFile                      string
+	tlsKeyFile                       string
+	startTimeout                     time.Duration
+	bodyLimit                        int64
+	timeout                          time.Duration
+	rootPath                         string
+	correlationIdHeader              string
+	basicAuthUsername                string
+	basicAuthPassword                string
+	downloadFromCfg                  downloadFromConfig
+	disableHealthCheckRouteTelemetry bool
+	enableDebugRoute                 bool
 
 	routes              []Route
 	externalMiddlewares []Middleware
@@ -50,7 +50,7 @@ type Api struct {
 	readyFn             []func() error
 	asyncCounters       []AsynchronousCounter
 	fs                  *gotenberg.FileSystem
-	logger              *zap.Logger
+	logger              *slog.Logger
 	srv                 *echo.Echo
 }
 
@@ -80,9 +80,10 @@ type Route struct {
 	// Optional.
 	IsMultipart bool
 
-	// DisableLogging disables the logging for this route.
+	// DisableTelemetry disables telemetry (logging, tracing, metrics) for
+	// this route.
 	// Optional.
-	DisableLogging bool
+	DisableTelemetry bool
 
 	// Handler is the function that handles the request.
 	// Required.
@@ -190,14 +191,26 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 			fs.Duration("api-timeout", time.Duration(30)*time.Second, "Set the time limit for requests")
 			fs.String("api-body-limit", "", "Set the body limit for multipart/form-data requests - it accepts values like 5MB, 1GB, etc")
 			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.String("api-correlation-id-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
 			fs.Bool("api-enable-basic-auth", false, "Enable basic authentication - will look for the GOTENBERG_API_BASIC_AUTH_USERNAME and GOTENBERG_API_BASIC_AUTH_PASSWORD environment variables")
 			fs.StringSlice("api-download-from-allow-list", []string{}, "Set the allowed URLs for the download from feature using regular expressions - supports multiple values")
 			fs.StringSlice("api-download-from-deny-list", []string{}, "Set the denied URLs for the download from feature using regular expressions - supports multiple values")
 			fs.Int("api-download-from-max-retry", 4, "Set the maximum number of retries for the download from feature")
 			fs.Bool("api-disable-download-from", false, "Disable the download from feature")
-			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
+			fs.Bool("api-disable-health-check-route-telemetry", false, "Disable telemetry for health check route")
 			fs.Bool("api-enable-debug-route", false, "Enable the debug route")
+
+			// Deprecated flags.
+			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")
+
+			err := errors.Join(
+				fs.MarkDeprecated("api-trace-header", "use --api-correlation-id-header instead"),
+				fs.MarkDeprecated("api-disable-health-check-logging", "use --api-disable-health-check-route-telemetry instead"),
+			)
+			if err != nil {
+				panic(err)
+			}
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(Api) },
@@ -215,14 +228,14 @@ func (a *Api) Provision(ctx *gotenberg.Context) error {
 	a.timeout = flags.MustDuration("api-timeout")
 	a.bodyLimit = flags.MustHumanReadableBytes("api-body-limit")
 	a.rootPath = flags.MustString("api-root-path")
-	a.traceHeader = flags.MustString("api-trace-header")
+	a.correlationIdHeader = flags.MustDeprecatedString("api-trace-header", "api-correlation-id-header")
 	a.downloadFromCfg = downloadFromConfig{
 		allowList: flags.MustRegexpSlice("api-download-from-allow-list"),
 		denyList:  flags.MustRegexpSlice("api-download-from-deny-list"),
 		maxRetry:  flags.MustInt("api-download-from-max-retry"),
 		disable:   flags.MustBool("api-disable-download-from"),
 	}
-	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")
+	a.disableHealthCheckRouteTelemetry = flags.MustDeprecatedBool("api-disable-health-check-logging", "api-disable-health-check-route-telemetry")
 	a.enableDebugRoute = flags.MustBool("api-enable-debug-route")
 
 	// Port from env?
@@ -328,17 +341,7 @@ func (a *Api) Provision(ctx *gotenberg.Context) error {
 	}
 
 	// Logger.
-	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
-	if err != nil {
-		return fmt.Errorf("get logger provider: %w", err)
-	}
-
-	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(a)
-	if err != nil {
-		return fmt.Errorf("get logger: %w", err)
-	}
-
-	a.logger = logger
+	a.logger = gotenberg.Logger(a)
 
 	// File system.
 	a.fs = gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
@@ -378,7 +381,7 @@ func (a *Api) Validate() error {
 		)
 	}
 
-	if len(strings.TrimSpace(a.traceHeader)) == 0 {
+	if len(strings.TrimSpace(a.correlationIdHeader)) == 0 {
 		err = multierr.Append(err,
 			errors.New("trace header must not be empty"),
 		)
@@ -442,28 +445,28 @@ func (a *Api) Start() error {
 	a.srv.HTTPErrorHandler = httpErrorHandler()
 
 	// Let's prepare the modules' routes.
-	var disableLoggingForPaths []string
+	var disableTelemetryForPaths []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, "/"))
+		if route.DisableTelemetry {
+			disableTelemetryForPaths = append(disableTelemetryForPaths, strings.TrimPrefix(route.Path, "/"))
 		}
 	}
 
-	// Check if the user wishes to add logging entries related to the health
-	// check route.
-	if a.disableHealthCheckLogging {
-		disableLoggingForPaths = append(disableLoggingForPaths, "health")
+	// Check if the user wishes to disable telemetry for the health check route.
+	if a.disableHealthCheckRouteTelemetry {
+		disableTelemetryForPaths = append(disableTelemetryForPaths, "health")
 	}
 
+	serverName := fmt.Sprintf("%s:%d", a.bindIp, a.port)
+
 	// Add the API middlewares.
 	a.srv.Pre(
 		latencyMiddleware(),
 		rootPathMiddleware(a.rootPath),
-		traceMiddleware(a.traceHeader),
 		outputFilenameMiddleware(),
-		loggerMiddleware(a.logger, disableLoggingForPaths),
+		telemetryMiddleware(a.logger, serverName, a.correlationIdHeader, disableTelemetryForPaths),
 	)
 
 	// Add the modules' middlewares in their respective stacks.
@@ -535,7 +538,9 @@ func (a *Api) Start() error {
 	)
 
 	// Let's not forget the health check routes...
-	checks := append(a.healthChecks, health.WithTimeout(a.timeout))
+	checks := make([]health.CheckerOption, len(a.healthChecks), len(a.healthChecks)+1)
+	copy(checks, a.healthChecks)
+	checks = append(checks, health.WithTimeout(a.timeout))
 	checker := health.NewChecker(checks...)
 	healthCheckHandler := health.NewHandler(checker)
 
@@ -600,7 +605,7 @@ func (a *Api) Start() error {
 			err = a.srv.StartH2CServer(fmt.Sprintf("%s:%d", a.bindIp, a.port), server)
 		}
 		if !errors.Is(err, http.ErrServerClosed) {
-			a.logger.Fatal(err.Error())
+			a.logger.ErrorContext(context.Background(), err.Error())
 		}
 	}()
 
@@ -627,12 +632,12 @@ func (a *Api) Stop(ctx context.Context) error {
 		case <-ctx.Done():
 			return a.srv.Shutdown(ctx)
 		default:
-			a.logger.Debug(fmt.Sprintf("%d asynchronous requests", count))
+			a.logger.DebugContext(ctx, fmt.Sprintf("%d asynchronous requests", count))
 			if count > 0 {
 				time.Sleep(1 * time.Second)
 				continue
 			}
-			a.logger.Debug("no more asynchronous requests, continue with shutdown")
+			a.logger.DebugContext(ctx, "no more asynchronous requests, continue with shutdown")
 			err := a.srv.Shutdown(ctx)
 			if err != nil {
 				return fmt.Errorf("shutdown: %w", err)

pkg/modules/api/context.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"mime"
 	"mime/multipart"
 	"net/http"
@@ -19,7 +20,8 @@ import (
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"github.com/mholt/archives"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/propagation"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/unicode/norm"
 
@@ -36,7 +38,7 @@ var (
 	ErrOutOfBoundsOutputPath = errors.New("output path is not within context's working directory")
 )
 
-// Context is the request context for a "multipart/form-data" requests.
+// Context is the request context for a "multipart/form-data" request.
 type Context struct {
 	dirPath      string
 	values       map[string][]string
@@ -45,7 +47,7 @@ type Context struct {
 	outputPaths  []string
 	cancelled    bool
 
-	logger     *zap.Logger
+	logger     *slog.Logger
 	echoCtx    echo.Context
 	mkdirAll   gotenberg.MkdirAll
 	pathRename gotenberg.PathRename
@@ -92,7 +94,7 @@ type downloadFrom struct {
 }
 
 // newContext returns a [Context] by parsing a "multipart/form-data" request.
-func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig, traceHeader, trace string) (*Context, context.CancelFunc, error) {
+func newContext(echoCtx echo.Context, logger *slog.Logger, fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(echoCtx.Request().Context(), timeout)
 
 	// We want to make sure the multipart/form-data does not exceed a given
@@ -137,12 +139,12 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 
 			err := os.RemoveAll(ctx.dirPath)
 			if err != nil {
-				ctx.logger.Error(fmt.Sprintf("remove context's working directory: %s", err))
+				ctx.logger.ErrorContext(context.Background(), fmt.Sprintf("remove context's working directory: %s", err))
 
 				return
 			}
 
-			ctx.logger.Debug(fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
+			ctx.logger.DebugContext(context.Background(), fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
 			ctx.cancelled = true
 		}
 	}()
@@ -230,7 +232,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 					return fmt.Errorf("filter URL: %w", err)
 				}
 
-				logger.Debug(fmt.Sprintf("download file from '%s'", dl.Url))
+				logger.DebugContext(ctx, fmt.Sprintf("download file from '%s'", dl.Url))
 
 				req, err := retryablehttp.NewRequest(http.MethodGet, dl.Url, nil)
 				if err != nil {
@@ -241,7 +243,16 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 				for key, value := range dl.ExtraHttpHeaders {
 					req.Header.Set(key, value)
 				}
-				req.Header.Set(traceHeader, trace)
+
+				// Inject OTEL trace context into outbound request.
+				otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))
+
+				// Propagate correlation ID header.
+				if correlationIdHeader, ok := echoCtx.Get("correlationIdHeader").(string); ok {
+					if correlationId, ok := echoCtx.Get("correlationId").(string); ok {
+						req.Header.Set(correlationIdHeader, correlationId)
+					}
+				}
 
 				client := &retryablehttp.Client{
 					HTTPClient: &http.Client{
@@ -265,7 +276,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 				defer func() {
 					err := resp.Body.Close()
 					if err != nil {
-						logger.Error(fmt.Sprintf("close response body from '%s': %s", dl.Url, err))
+						logger.ErrorContext(ctx, fmt.Sprintf("close response body from '%s': %s", dl.Url, err))
 					}
 				}()
 
@@ -316,7 +327,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 				defer func() {
 					err := out.Close()
 					if err != nil {
-						logger.Error(fmt.Sprintf("close local file: %s", err))
+						logger.ErrorContext(ctx, fmt.Sprintf("close local file: %s", err))
 					}
 				}()
 
@@ -359,7 +370,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		defer func() {
 			err := in.Close()
 			if err != nil {
-				logger.Error(fmt.Sprintf("close file header: %s", err))
+				logger.ErrorContext(context.Background(), fmt.Sprintf("close file header: %s", err))
 			}
 		}()
 
@@ -379,7 +390,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		defer func() {
 			err := out.Close()
 			if err != nil {
-				logger.Error(fmt.Sprintf("close local file: %s", err))
+				logger.ErrorContext(context.Background(), fmt.Sprintf("close local file: %s", err))
 			}
 		}()
 
@@ -407,10 +418,10 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		}
 	}
 
-	ctx.Log().Debug(fmt.Sprintf("form fields: %+v", ctx.values))
-	ctx.Log().Debug(fmt.Sprintf("form files: %+v", ctx.files))
-	ctx.Log().Debug(fmt.Sprintf("form files by field: %+v", ctx.filesByField))
-	ctx.Log().Debug(fmt.Sprintf("total bytes: %d", totalBytesRead.Load()))
+	ctx.Log().DebugContext(ctx, fmt.Sprintf("form fields: %+v", ctx.values))
+	ctx.Log().DebugContext(ctx, fmt.Sprintf("form files: %+v", ctx.files))
+	ctx.Log().DebugContext(ctx, fmt.Sprintf("form files by field: %+v", ctx.filesByField))
+	ctx.Log().DebugContext(ctx, fmt.Sprintf("total bytes: %d", totalBytesRead.Load()))
 
 	return ctx, cancel, err
 }
@@ -462,7 +473,7 @@ func (ctx *Context) CreateSubDirectory(dirName string) (string, error) {
 // Rename is just a wrapper around [os.Rename], as we need to mock this
 // behavior in our tests.
 func (ctx *Context) Rename(oldpath, newpath string) error {
-	ctx.Log().Debug(fmt.Sprintf("rename %s to %s", oldpath, newpath))
+	ctx.Log().DebugContext(ctx, fmt.Sprintf("rename %s to %s", oldpath, newpath))
 	err := ctx.pathRename.Rename(oldpath, newpath)
 	if err != nil {
 		return fmt.Errorf("rename path: %w", err)
@@ -488,8 +499,8 @@ func (ctx *Context) AddOutputPaths(paths ...string) error {
 	return nil
 }
 
-// Log returns the context [zap.Logger].
-func (ctx *Context) Log() *zap.Logger {
+// Log returns the context [slog.Logger].
+func (ctx *Context) Log() *slog.Logger {
 	return ctx.logger
 }
 
@@ -505,7 +516,7 @@ func (ctx *Context) BuildOutputFile() (string, error) {
 	}
 
 	if len(ctx.outputPaths) == 1 {
-		ctx.logger.Debug(fmt.Sprintf("only one output file '%s', skip archive creation", ctx.outputPaths[0]))
+		ctx.logger.DebugContext(ctx, fmt.Sprintf("only one output file '%s', skip archive creation", ctx.outputPaths[0]))
 		return ctx.outputPaths[0], nil
 	}
 
@@ -528,7 +539,7 @@ func (ctx *Context) BuildOutputFile() (string, error) {
 	defer func(out *os.File) {
 		err := out.Close()
 		if err != nil {
-			ctx.logger.Error(fmt.Sprintf("close zip file: %s", err))
+			ctx.logger.ErrorContext(ctx, fmt.Sprintf("close zip file: %s", err))
 		}
 	}(out)
 
@@ -537,7 +548,7 @@ func (ctx *Context) BuildOutputFile() (string, error) {
 		return "", fmt.Errorf("archive output files: %w", err)
 	}
 
-	ctx.logger.Debug(fmt.Sprintf("archive '%s' created", archivePath))
+	ctx.logger.DebugContext(ctx, fmt.Sprintf("archive '%s' created", archivePath))
 
 	return archivePath, nil
 }

pkg/modules/api/context_test.go

@@ -3,6 +3,7 @@ package api
 import (
 	"bytes"
 	"context"
+	"log/slog"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
@@ -10,7 +11,6 @@ import (
 	"time"
 
 	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -35,14 +35,14 @@ func TestNewContext_Cancellation(t *testing.T) {
 	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
 
-	logger := zap.NewNop()
+	logger := slog.New(slog.DiscardHandler)
 	fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 	timeout := time.Duration(10) * time.Second
 	downloadFromCfg := downloadFromConfig{
 		disable: true,
 	}
 
-	ctx, cancel, err := newContext(c, logger, fs, timeout, 0, downloadFromCfg, "trace", "trace")
+	ctx, cancel, err := newContext(c, logger, fs, timeout, 0, downloadFromCfg)
 	if err != nil {
 		t.Fatalf("expected no error from newContext, got: %v", err)
 	}

pkg/modules/api/middlewares.go

@@ -5,6 +5,7 @@ import (
 	"crypto/subtle"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"path/filepath"
 	"strings"
@@ -13,9 +14,13 @@ import (
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	semconvutil "github.com/gotenberg/gotenberg/v8/pkg/gotenberg/semconv"
 )
 
 var (
@@ -69,8 +74,7 @@ func ParseError(err error) (int, string) {
 		return http.StatusBadRequest, "At least one PDF engine cannot process the requested rotation angle, while others may have failed due to different issues"
 	}
 
-	var invalidArgsError *gotenberg.PdfEngineInvalidArgsError
-	if errors.As(err, &invalidArgsError) {
+	if invalidArgsError, ok := errors.AsType[*gotenberg.PdfEngineInvalidArgsError](err); ok {
 		return http.StatusBadRequest, invalidArgsError.Error()
 	}
 
@@ -87,14 +91,14 @@ func ParseError(err error) (int, string) {
 // returns a response as "text/plain; charset=UTF-8".
 func httpErrorHandler() echo.HTTPErrorHandler {
 	return func(err error, c echo.Context) {
-		logger := c.Get("logger").(*zap.Logger)
+		logger := c.Get("logger").(*slog.Logger)
 		status, message := ParseError(err)
 
 		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()))
+			logger.ErrorContext(c.Request().Context(), fmt.Sprintf("send error response: %s", err.Error()))
 		}
 	}
 }
@@ -138,32 +142,6 @@ func rootPathMiddleware(rootPath string) echo.MiddlewareFunc {
 	}
 }
 
-// traceMiddleware sets the request identifier in the [echo.Context] under
-// "trace". Its value is either retrieved from the trace header or generated if
-// 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 {
-			// Get or create the request identifier.
-			trace := c.Request().Header.Get(header)
-
-			if trace == "" {
-				trace = uuid.New().String()
-			}
-
-			c.Set("trace", trace)
-			c.Set("traceHeader", header)
-			c.Response().Header().Add(header, trace)
-
-			// Call the next middleware in the chain.
-			return next(c)
-		}
-	}
-}
-
 // outputFilenameMiddleware sets the output filename in the [echo.Context]
 // under "outputFilename".
 //
@@ -183,59 +161,28 @@ func outputFilenameMiddleware() echo.MiddlewareFunc {
 	}
 }
 
-// loggerMiddleware sets the logger in the [echo.Context] under "logger" and
-// logs a synchronous request result.
+// telemetryMiddleware manages telemetry. It sets the correlation ID in the
+// [echo.Context] under "correlationId".
 //
-//	logger := c.Get("logger").(*zap.Logger)
-func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.MiddlewareFunc {
+//	correlationIdHeader := c.Get("correlationIdHeader").(string)
+//	correlationId := c.Get("correlationId").(string)
+func telemetryMiddleware(logger *slog.Logger, serverName, correlationIdHeader string, disableTelemetryForPaths []string) echo.MiddlewareFunc {
+	meter := gotenberg.Meter()
+	semconvSrv := semconvutil.NewHTTPServer(meter)
+
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			startTime := c.Get("startTime").(time.Time)
-			trace := c.Get("trace").(string)
 			rootPath := c.Get("rootPath").(string)
 
-			// Create the application logger and add it to our locals.
-			appLogger := logger.
-				With(zap.String("log_type", "application")).
-				With(zap.String("trace", trace))
+			request := c.Request()
+			savedCtx := request.Context()
+			defer func() {
+				request = request.WithContext(savedCtx)
+				c.SetRequest(request)
+			}()
 
-			c.Set("logger", appLogger.Named(func() string {
-				return strings.ReplaceAll(
-					strings.ReplaceAll(c.Request().URL.Path, rootPath, ""),
-					"/",
-					"",
-				)
-			}()))
-
-			// Call the next middleware in the chain.
-			err := next(c)
-			if err != nil {
-				c.Error(err)
-			}
-
-			// Create the access logger.
-			accessLogger := logger.
-				With(zap.String("log_type", "access")).
-				With(zap.String("trace", trace))
-
-			for _, path := range disableLoggingForPaths {
-				URI := fmt.Sprintf("%s%s", rootPath, path)
-
-				if c.Request().RequestURI == URI {
-					return nil
-				}
-			}
-
-			// Last piece for calculating the latency.
-			finishTime := time.Now()
-
-			// Now, let's log!
-			fields := make([]zap.Field, 12)
-			fields[0] = zap.String("remote_ip", c.RealIP())
-			fields[1] = zap.String("host", c.Request().Host)
-			fields[2] = zap.String("uri", c.Request().RequestURI)
-			fields[3] = zap.String("method", c.Request().Method)
-			fields[4] = zap.String("path", func() string {
+			routePath := func() string {
 				path := c.Request().URL.Path
 
 				if path == "" {
@@ -243,21 +190,127 @@ func loggerMiddleware(logger *zap.Logger, disableLoggingForPaths []string) echo.
 				}
 
 				return path
-			}())
-			fields[5] = zap.String("referer", c.Request().Referer())
-			fields[6] = zap.String("user_agent", c.Request().UserAgent())
-			fields[7] = zap.Int("status", c.Response().Status)
-			fields[8] = zap.Int64("latency", int64(finishTime.Sub(startTime)))
-			fields[9] = zap.String("latency_human", finishTime.Sub(startTime).String())
-			fields[10] = zap.Int64("bytes_in", c.Request().ContentLength)
-			fields[11] = zap.Int64("bytes_out", c.Response().Size)
+			}()
+
+			// Evaluate if we should skip telemetry for this path.
+			skipTelemetry := false
+			for _, path := range disableTelemetryForPaths {
+				URI := fmt.Sprintf("%s%s", rootPath, path)
+				if c.Request().RequestURI == URI {
+					skipTelemetry = true
+					break
+				}
+			}
+
+			if skipTelemetry {
+				c.Set("logger", slog.New(slog.DiscardHandler))
+
+				err := next(c)
+				if err != nil {
+					c.Error(err)
+				}
+				return nil
+			}
+
+			correlationId := request.Header.Get(correlationIdHeader)
+			if correlationId == "" {
+				correlationId = uuid.NewString()
+			}
+			c.Set("correlationIdHeader", correlationIdHeader)
+			c.Set("correlationId", correlationId)
+
+			ctx := otel.GetTextMapPropagator().Extract(savedCtx, propagation.HeaderCarrier(request.Header))
+
+			rAttr := semconvSrv.Route(routePath)
+			opts := []trace.SpanStartOption{
+				trace.WithAttributes(
+					semconvSrv.RequestTraceAttrs(serverName, request, semconvutil.RequestTraceAttrsOpts{})...,
+				),
+				trace.WithSpanKind(trace.SpanKindServer),
+				trace.WithAttributes(rAttr),
+			}
+			spanName := strings.ToUpper(c.Request().Method) + " " + routePath
+
+			tracer := gotenberg.Tracer()
+			ctx, span := tracer.Start(ctx, spanName, opts...)
+			defer span.End()
+
+			otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(c.Response().Header()))
+
+			c.Response().Header().Set(correlationIdHeader, correlationId)
+			c.SetRequest(c.Request().WithContext(ctx))
+
+			appLogger := logger.
+				With(slog.String("log_type", "application")).
+				With(slog.String("correlation_id", correlationId))
+
+			loggerName := strings.ReplaceAll(
+				strings.ReplaceAll(c.Request().URL.Path, rootPath, ""),
+				"/",
+				"",
+			)
+
+			c.Set("logger", appLogger.With(slog.String("logger", loggerName)))
+
+			// Call the next middleware in the chain.
+			err := next(c)
+			finishTime := time.Now()
+
+			status := c.Response().Status
+			if err != nil {
+				parsedStatus, _ := ParseError(err)
+				status = parsedStatus
+
+				span.SetAttributes(attribute.String("error", err.Error()))
+				c.Error(err)
+			}
+
+			span.SetStatus(semconvSrv.Status(status))
+			span.SetAttributes(semconvSrv.ResponseTraceAttrs(semconvutil.ResponseTelemetry{
+				StatusCode: status,
+				WriteBytes: c.Response().Size,
+			})...)
+
+			accessLogger := logger.
+				With(slog.String("log_type", "access")).
+				With(slog.String("correlation_id", correlationId)).
+				With(slog.String("remote_ip", c.RealIP())).
+				With(slog.String("host", c.Request().Host)).
+				With(slog.String("uri", c.Request().RequestURI)).
+				With(slog.String("method", c.Request().Method)).
+				With(slog.String("path", routePath)).
+				With(slog.String("referer", c.Request().Referer())).
+				With(slog.String("user_agent", c.Request().UserAgent())).
+				With(slog.Int("status", c.Response().Status)).
+				With(slog.Int64("latency", int64(finishTime.Sub(startTime)))).
+				With(slog.String("latency_human", finishTime.Sub(startTime).String())).
+				With(slog.Int64("bytes_in", c.Request().ContentLength)).
+				With(slog.Int64("bytes_out", c.Response().Size))
 
 			if err != nil {
-				accessLogger.Error(err.Error(), fields...)
+				accessLogger.ErrorContext(ctx, err.Error())
 			} else {
-				accessLogger.Info("request handled", fields...)
+				accessLogger.InfoContext(ctx, "request handled")
 			}
 
+			additionalAttributes := []attribute.KeyValue{
+				semconvSrv.Route(routePath),
+			}
+
+			semconvSrv.RecordMetrics(ctx, semconvutil.ServerMetricData{
+				ServerName:   serverName,
+				ResponseSize: c.Response().Size,
+				MetricAttributes: semconvutil.MetricAttributes{
+					Req:                  request,
+					StatusCode:           status,
+					AdditionalAttributes: additionalAttributes,
+				},
+				MetricData: semconvutil.MetricData{
+					RequestSize: request.ContentLength,
+					ElapsedTime: float64(time.Since(startTime)) / float64(time.Millisecond),
+				},
+			})
+
 			return nil
 		}
 	}
@@ -284,13 +337,11 @@ func basicAuthMiddleware(username, password string) echo.MiddlewareFunc {
 func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
-			logger := c.Get("logger").(*zap.Logger)
-			traceHeader := c.Get("traceHeader").(string)
-			trace := c.Get("trace").(string)
+			logger := c.Get("logger").(*slog.Logger)
 
 			// We create a context with a timeout so that underlying processes are
 			// able to stop early and correctly handle a timeout scenario.
-			ctx, cancel, err := newContext(c, logger, fs, timeout, bodyLimit, downloadFromCfg, traceHeader, trace)
+			ctx, cancel, err := newContext(c, logger, fs, timeout, bodyLimit, downloadFromCfg)
 			if err != nil {
 				cancel()
 
@@ -344,7 +395,7 @@ func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration, bodyLimi
 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)
+			logger := c.Get("logger").(*slog.Logger)
 
 			// Define a hard timeout if the route handler fails to timeout as
 			// expected.
@@ -361,7 +412,7 @@ func hardTimeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
 				// This deferred function allows us to recover from such scenarios.
 				defer func() {
 					if r := recover(); r != nil {
-						logger.Debug(fmt.Sprintf("recovering from a panic (possible cause being a hard timeout): %s", r))
+						logger.DebugContext(hardTimeoutCtx, fmt.Sprintf("recovering from a panic (possible cause being a hard timeout): %s", r))
 					}
 				}()
 
@@ -373,7 +424,7 @@ func hardTimeoutMiddleware(hardTimeout time.Duration) echo.MiddlewareFunc {
 			case err := <-errChan:
 				return err
 			case <-hardTimeoutCtx.Done():
-				logger.Debug("hard timeout as the route handler did not timeout as expected")
+				logger.DebugContext(hardTimeoutCtx, "hard timeout as the route handler did not timeout as expected")
 
 				return fmt.Errorf("hard timeout: %w", hardTimeoutCtx.Err())
 			}

pkg/modules/api/mocks.go

@@ -1,9 +1,10 @@
 package api
 
 import (
+	"log/slog"
+
 	"github.com/alexliesenfeld/health"
 	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -73,8 +74,8 @@ func (ctx *ContextMock) OutputPaths() []string {
 // SetLogger sets the logger.
 //
 //	ctx := &api.ContextMock{Context: &api.Context{}}
-//	ctx.SetLogger(zap.NewNop())
-func (ctx *ContextMock) SetLogger(logger *zap.Logger) {
+//	ctx.SetLogger(slog.Default())
+func (ctx *ContextMock) SetLogger(logger *slog.Logger) {
 	ctx.logger = logger
 }
 

pkg/modules/chromium/browser.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"strings"
 	"sync"
@@ -18,15 +19,14 @@ import (
 	"github.com/chromedp/chromedp"
 	"github.com/dlclark/regexp2"
 	"github.com/shirou/gopsutil/v4/process"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 type browser interface {
 	gotenberg.Process
-	pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
-	screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+	pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error
+	screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error
 }
 
 type browserArguments struct {
@@ -72,7 +72,7 @@ func newChromiumBrowser(arguments browserArguments) browser {
 	return b
 }
 
-func (b *chromiumBrowser) Start(logger *zap.Logger) error {
+func (b *chromiumBrowser) Start(logger *slog.Logger) error {
 	if b.isStarted.Load() {
 		return errors.New("browser is already started")
 	}
@@ -164,7 +164,7 @@ func (b *chromiumBrowser) Start(logger *zap.Logger) error {
 	return nil
 }
 
-func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
+func (b *chromiumBrowser) Stop(logger *slog.Logger) error {
 	if !b.isStarted.Load() {
 		// No big deal? Like calling cancel twice.
 		return nil
@@ -181,7 +181,7 @@ func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
 		// Clean up stuck processes.
 		ps, err := process.Processes()
 		if err != nil {
-			logger.Error(fmt.Sprintf("list processes: %v", err))
+			logger.ErrorContext(context.Background(), fmt.Sprintf("list processes: %v", err))
 		} else {
 			for _, p := range ps {
 				func() {
@@ -199,9 +199,9 @@ func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
 
 					err = p.KillWithContext(killCtx)
 					if err != nil {
-						logger.Error(fmt.Sprintf("kill process: %v", err))
+						logger.ErrorContext(context.Background(), fmt.Sprintf("kill process: %v", err))
 					} else {
-						logger.Debug(fmt.Sprintf("Chromium process %d killed", p.Pid))
+						logger.DebugContext(context.Background(), fmt.Sprintf("Chromium process %d killed", p.Pid))
 					}
 				}()
 			}
@@ -215,15 +215,15 @@ func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
 
 			err = os.RemoveAll(userProfileDirPath)
 			if err != nil {
-				logger.Error(fmt.Sprintf("remove Chromium's user profile directory: %s", err))
+				logger.ErrorContext(context.Background(), fmt.Sprintf("remove Chromium's user profile directory: %s", err))
 			} else {
-				logger.Debug(fmt.Sprintf("'%s' Chromium's user profile directory removed", userProfileDirPath))
+				logger.DebugContext(context.Background(), fmt.Sprintf("'%s' Chromium's user profile directory removed", userProfileDirPath))
 			}
 
 			// Also, remove Chromium-specific files in the temporary directory.
-			err = gotenberg.GarbageCollect(logger, os.TempDir(), []string{".org.chromium.Chromium", ".com.google.Chrome"}, expirationTime)
+			err = gotenberg.GarbageCollect(context.Background(), logger, os.TempDir(), []string{".org.chromium.Chromium", ".com.google.Chrome"}, expirationTime)
 			if err != nil {
-				logger.Error(err.Error())
+				logger.ErrorContext(context.Background(), err.Error())
 			}
 		}()
 	}(copyUserProfileDirPath, expirationTime)
@@ -239,7 +239,7 @@ func (b *chromiumBrowser) Stop(logger *zap.Logger) error {
 	return nil
 }
 
-func (b *chromiumBrowser) Healthy(logger *zap.Logger) bool {
+func (b *chromiumBrowser) Healthy(logger *slog.Logger) bool {
 	// Good to know: the supervisor does not call this method if no first start
 	// or if the process is restarting.
 
@@ -266,14 +266,14 @@ func (b *chromiumBrowser) Healthy(logger *zap.Logger) bool {
 		return err
 	}))
 	if err != nil {
-		logger.Error(fmt.Sprintf("browser health check failed: %s", err))
+		logger.ErrorContext(context.Background(), fmt.Sprintf("browser health check failed: %s", err))
 		return false
 	}
 
 	return true
 }
 
-func (b *chromiumBrowser) pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+func (b *chromiumBrowser) pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error {
 	// Note: no error wrapping because it leaks on errors we want to display to
 	// the end user.
 	return b.do(ctx, logger, url, options.Options, chromedp.Tasks{
@@ -299,7 +299,7 @@ func (b *chromiumBrowser) pdf(ctx context.Context, logger *zap.Logger, url, outp
 	})
 }
 
-func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+func (b *chromiumBrowser) screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error {
 	// Note: no error wrapping because it leaks on errors we want to display to
 	// the end user.
 	return b.do(ctx, logger, url, options.Options, chromedp.Tasks{
@@ -326,7 +326,7 @@ func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, ur
 	})
 }
 
-func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string, options Options, tasks chromedp.Tasks) error {
+func (b *chromiumBrowser) do(ctx context.Context, logger *slog.Logger, url string, options Options, tasks chromedp.Tasks) error {
 	if !b.isStarted.Load() {
 		return errors.New("browser not started, cannot handle tasks")
 	}

pkg/modules/chromium/chromium.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"strings"
@@ -14,7 +15,8 @@ import (
 	"github.com/chromedp/cdproto/network"
 	"github.com/dlclark/regexp2"
 	flag "github.com/spf13/pflag"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
@@ -91,10 +93,17 @@ type Chromium struct {
 	maxConcurrency int64
 	args           browserArguments
 
-	logger     *zap.Logger
+	logger     *slog.Logger
 	browser    browser
 	supervisor gotenberg.ProcessSupervisor
 	engine     gotenberg.PdfEngine
+
+	reqsCounter               metric.Int64Counter
+	errsCounter               metric.Int64Counter
+	conversionDurationCounter metric.Float64Histogram
+	queueWaitDurationCounter  metric.Float64Histogram
+	pdfOutputSizeCounter      metric.Int64Histogram
+	imageOutputSizeCounter    metric.Int64Histogram
 }
 
 // Options are the common options for all conversions.
@@ -400,8 +409,8 @@ type ExtraHttpHeader struct {
 
 // Api helps to interact with Chromium for converting HTML documents to PDF.
 type Api interface {
-	Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
-	Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+	Pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error
+	Screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error
 }
 
 // Provider is a module interface that exposes a method for creating an [Api]
@@ -488,15 +497,7 @@ func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 	}
 
 	// Logger.
-	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
-	if err != nil {
-		return fmt.Errorf("get logger provider: %w", err)
-	}
-	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(mod)
-	if err != nil {
-		return fmt.Errorf("get logger: %w", err)
-	}
-	mod.logger = logger.Named("browser")
+	mod.logger = gotenberg.Logger(mod).With(slog.String("logger", "browser"))
 
 	// Process.
 	mod.browser = newChromiumBrowser(mod.args)
@@ -513,6 +514,109 @@ func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 	}
 	mod.engine = engine
 
+	// Metrics.
+	meter := gotenberg.Meter()
+
+	// Observable gauges.
+	_, err = meter.Int64ObservableGauge(
+		"chromium.requests.active",
+		metric.WithDescription("Current number of active Chromium requests"),
+		metric.WithUnit("{request}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(mod.supervisor.ActiveTasksCount())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.requests.active gauge: %w", err)
+	}
+
+	_, err = meter.Int64ObservableGauge(
+		"chromium.requests.queue_size",
+		metric.WithDescription("Current number of Chromium conversion requests waiting to be treated"),
+		metric.WithUnit("{request}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(mod.supervisor.ReqQueueSize())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.requests.queue_size gauge: %w", err)
+	}
+
+	_, err = meter.Int64ObservableCounter(
+		"chromium.process.restarts.total",
+		metric.WithDescription("Current number of Chromium restarts"),
+		metric.WithUnit("{restart}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(mod.supervisor.RestartsCount())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.process.restarts.total counter: %w", err)
+	}
+
+	// Counters.
+	mod.reqsCounter, err = meter.Int64Counter(
+		"chromium.requests.total",
+		metric.WithDescription("Total number of Chromium conversion requests"),
+		metric.WithUnit("{request}"),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.requests.total counter: %w", err)
+	}
+
+	mod.errsCounter, err = meter.Int64Counter(
+		"chromium.errors.total",
+		metric.WithDescription("Total number of Chromium conversion errors"),
+		metric.WithUnit("{error}"),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.errors.total counter: %w", err)
+	}
+
+	// Histograms.
+	durationBuckets := metric.WithExplicitBucketBoundaries(0.5, 1, 2, 5, 10, 30, 60)
+
+	mod.conversionDurationCounter, err = meter.Float64Histogram(
+		"chromium.conversion.duration",
+		metric.WithDescription("Duration of Chromium conversions"),
+		metric.WithUnit("s"),
+		durationBuckets,
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.conversion.duration histogram: %w", err)
+	}
+
+	mod.queueWaitDurationCounter, err = meter.Float64Histogram(
+		"chromium.queue.wait.duration",
+		metric.WithDescription("Duration of waiting in queue for Chromium conversions"),
+		metric.WithUnit("s"),
+		durationBuckets,
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.queue.wait.duration histogram: %w", err)
+	}
+
+	mod.pdfOutputSizeCounter, err = meter.Int64Histogram(
+		"chromium.pdf.output.size",
+		metric.WithDescription("Size of PDF output from Chromium conversions"),
+		metric.WithUnit("By"),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.pdf.output.size histogram: %w", err)
+	}
+
+	mod.imageOutputSizeCounter, err = meter.Int64Histogram(
+		"chromium.image.output.size",
+		metric.WithDescription("Size of image output from Chromium screenshots"),
+		metric.WithUnit("By"),
+	)
+	if err != nil {
+		return fmt.Errorf("create chromium.image.output.size histogram: %w", err)
+	}
+
 	return nil
 }
 
@@ -563,7 +667,7 @@ func (mod *Chromium) StartupMessage() string {
 func (mod *Chromium) Stop(ctx context.Context) error {
 	// Block until the context is done so that another module may gracefully
 	// stop before we do a shutdown.
-	mod.logger.Debug("wait for the end of grace duration")
+	mod.logger.DebugContext(ctx, "wait for the end of grace duration")
 
 	<-ctx.Done()
 
@@ -679,20 +783,138 @@ func (mod *Chromium) Routes() ([]api.Route, error) {
 }
 
 // Pdf converts a URL to PDF.
-func (mod *Chromium) Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
-	// Note: no error wrapping because it leaks on errors we want to display to
-	// the end user.
-	return mod.supervisor.Run(ctx, logger, func() error {
+func (mod *Chromium) Pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error {
+	start := time.Now()
+	var conversionStart time.Time
+
+	err := mod.supervisor.Run(ctx, logger, func() error {
+		conversionStart = time.Now()
 		return mod.browser.pdf(ctx, logger, url, outputPath, options)
 	})
+
+	end := time.Now()
+
+	status := "success"
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+			status = "timeout"
+		} else {
+			status = "error"
+		}
+
+		reason := "unknown"
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			reason = "timeout"
+		case errors.Is(err, context.Canceled):
+			reason = "context_cancelled"
+		case errors.Is(err, ErrInvalidHttpStatusCode) || errors.Is(err, ErrInvalidResourceHttpStatusCode) || errors.Is(err, ErrLoadingFailed) || errors.Is(err, ErrResourceLoadingFailed) || errors.Is(err, ErrInvalidEvaluationExpression) || errors.Is(err, ErrInvalidSelectorQuery):
+			reason = "invalid_input"
+		case errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) || errors.Is(err, gotenberg.ErrProcessAlreadyRestarting):
+			reason = "chromium_unavailable"
+		}
+
+		mod.errsCounter.Add(ctx, 1, metric.WithAttributes(
+			attribute.String("reason", reason),
+		))
+	}
+
+	if !conversionStart.IsZero() {
+		waitDuration := conversionStart.Sub(start).Seconds()
+		conversionDuration := end.Sub(conversionStart).Seconds()
+
+		mod.queueWaitDurationCounter.Record(ctx, waitDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+		mod.conversionDurationCounter.Record(ctx, conversionDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+	} else {
+		waitDuration := end.Sub(start).Seconds()
+		mod.queueWaitDurationCounter.Record(ctx, waitDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+	}
+
+	mod.reqsCounter.Add(ctx, 1, metric.WithAttributes(
+		attribute.String("status", status),
+	))
+
+	if err == nil {
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil {
+			mod.pdfOutputSizeCounter.Record(ctx, fileInfo.Size())
+		}
+	}
+
+	return err
 }
 
-func (mod *Chromium) Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
-	// Note: no error wrapping because it leaks on errors we want to display to
-	// the end user.
-	return mod.supervisor.Run(ctx, logger, func() error {
+func (mod *Chromium) Screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error {
+	start := time.Now()
+	var conversionStart time.Time
+
+	err := mod.supervisor.Run(ctx, logger, func() error {
+		conversionStart = time.Now()
 		return mod.browser.screenshot(ctx, logger, url, outputPath, options)
 	})
+
+	end := time.Now()
+
+	status := "success"
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+			status = "timeout"
+		} else {
+			status = "error"
+		}
+
+		reason := "unknown"
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			reason = "timeout"
+		case errors.Is(err, context.Canceled):
+			reason = "context_cancelled"
+		case errors.Is(err, ErrInvalidHttpStatusCode) || errors.Is(err, ErrInvalidResourceHttpStatusCode) || errors.Is(err, ErrLoadingFailed) || errors.Is(err, ErrResourceLoadingFailed) || errors.Is(err, ErrInvalidEvaluationExpression) || errors.Is(err, ErrInvalidSelectorQuery):
+			reason = "invalid_input"
+		case errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded):
+			reason = "chromium_maximum_queue_size_exceeded"
+		case errors.Is(err, gotenberg.ErrProcessAlreadyRestarting):
+			reason = "chromium_unavailable"
+		}
+
+		mod.errsCounter.Add(ctx, 1, metric.WithAttributes(
+			attribute.String("reason", reason),
+		))
+	}
+
+	if !conversionStart.IsZero() {
+		waitDuration := conversionStart.Sub(start).Seconds()
+		conversionDuration := end.Sub(conversionStart).Seconds()
+
+		mod.queueWaitDurationCounter.Record(ctx, waitDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+		mod.conversionDurationCounter.Record(ctx, conversionDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+	} else {
+		waitDuration := end.Sub(start).Seconds()
+		mod.queueWaitDurationCounter.Record(ctx, waitDuration, metric.WithAttributes(
+			attribute.String("status", status),
+		))
+	}
+
+	mod.reqsCounter.Add(ctx, 1, metric.WithAttributes(
+		attribute.String("status", status),
+	))
+
+	if err == nil {
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil {
+			mod.imageOutputSizeCounter.Record(ctx, fileInfo.Size())
+		}
+	}
+
+	return err
 }
 
 // Interface guards.

pkg/modules/chromium/debug.go

@@ -1,28 +1,28 @@
 package chromium
 
 import (
+	"context"
 	"fmt"
 	"io"
-
-	"go.uber.org/zap"
+	"log/slog"
 )
 
-// debugLogger is wrapper around a [zap.Logger] which is used for debugging
+// debugLogger is wrapper around a [slog.Logger] which is used for debugging
 // Chromium.
 type debugLogger struct {
-	logger *zap.Logger
+	logger *slog.Logger
 }
 
 // Write logs the bytes in a debug message.
 func (debug *debugLogger) Write(p []byte) (n int, err error) {
-	debug.logger.Debug(string(p))
+	debug.logger.DebugContext(context.Background(), string(p))
 
 	return len(p), nil
 }
 
 // Printf logs a debug message.
 func (debug *debugLogger) Printf(format string, v ...any) {
-	debug.logger.Debug(fmt.Sprintf(format, v...))
+	debug.logger.DebugContext(context.Background(), fmt.Sprintf(format, v...))
 }
 
 // Interface guards.

pkg/modules/chromium/events.go

@@ -3,6 +3,7 @@ package chromium
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"net/url"
 	"slices"
@@ -17,7 +18,6 @@ import (
 	"github.com/chromedp/chromedp"
 	"github.com/dlclark/regexp2"
 	"go.uber.org/multierr"
-	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -33,29 +33,28 @@ type eventRequestPausedOptions struct {
 // allowed or not.  It also set the extra HTTP headers, if any.
 // See https://github.com/gotenberg/gotenberg/issues/1011.
 // TODO: https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs (experimental for now).
-func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, options eventRequestPausedOptions) {
+func listenForEventRequestPaused(ctx context.Context, logger *slog.Logger, options eventRequestPausedOptions) {
 	if len(options.extraHttpHeaders) == 0 {
-		logger.Debug("no extra HTTP headers")
+		logger.DebugContext(ctx, "no extra HTTP headers")
 	} else {
-		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", options.extraHttpHeaders))
+		logger.DebugContext(ctx, fmt.Sprintf("extra HTTP headers: %+v", options.extraHttpHeaders))
 	}
 
 	chromedp.ListenTarget(ctx, func(ev any) {
-		switch e := ev.(type) {
-		case *fetch.EventRequestPaused:
+		if e, ok := ev.(*fetch.EventRequestPaused); ok {
 			go func() {
-				logger.Debug(fmt.Sprintf("event EventRequestPaused fired for '%s'", e.Request.URL))
+				logger.DebugContext(ctx, fmt.Sprintf("event EventRequestPaused fired for '%s'", e.Request.URL))
 				allow := true
 
 				deadline, ok := ctx.Deadline()
 				if !ok {
-					logger.Error("context has no deadline, cannot filter URL")
+					logger.ErrorContext(ctx, "context has no deadline, cannot filter URL")
 					return
 				}
 
 				err := gotenberg.FilterDeadline(options.allowList, options.denyList, e.Request.URL, deadline)
 				if err != nil {
-					logger.Warn(err.Error())
+					logger.WarnContext(ctx, err.Error())
 					allow = false
 				}
 
@@ -73,7 +72,7 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, option
 					}
 
 					if !prefixMatch {
-						logger.Warn(fmt.Sprintf("'%s' is not within any allowed file prefix", e.Request.URL))
+						logger.WarnContext(ctx, fmt.Sprintf("'%s' is not within any allowed file prefix", e.Request.URL))
 						allow = false
 					}
 				}
@@ -85,7 +84,7 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, option
 					req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
 					err = req.Do(executorCtx)
 					if err != nil {
-						logger.Error(fmt.Sprintf("fail request: %s", err))
+						logger.ErrorContext(ctx, fmt.Sprintf("fail request: %s", err))
 					}
 					return
 				}
@@ -101,25 +100,26 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, option
 					for _, header := range options.extraHttpHeaders {
 						if header.Scope == nil {
 							// Non-scoped header.
-							logger.Debug(fmt.Sprintf("extra HTTP header '%s' will be set for request URL '%s'", header.Name, e.Request.URL))
+							logger.DebugContext(ctx, fmt.Sprintf("extra HTTP header '%s' will be set for request URL '%s'", header.Name, e.Request.URL))
 							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
 							continue
 						}
 
 						ok, err := header.Scope.MatchString(e.Request.URL)
-						if err != nil {
-							logger.Error(fmt.Sprintf("fail to match extra HTTP header '%s' scope with URL '%s': %s", header.Name, e.Request.URL, err))
-						} else if ok {
-							logger.Debug(fmt.Sprintf("extra HTTP header '%s' (scoped) will be set for request URL '%s'", header.Name, e.Request.URL))
+						switch {
+						case err != nil:
+							logger.ErrorContext(ctx, fmt.Sprintf("fail to match extra HTTP header '%s' scope with URL '%s': %s", header.Name, e.Request.URL, err))
+						case ok:
+							logger.DebugContext(ctx, fmt.Sprintf("extra HTTP header '%s' (scoped) will be set for request URL '%s'", header.Name, e.Request.URL))
 							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
-						} else {
-							logger.Debug(fmt.Sprintf("scoped extra HTTP header '%s' (scoped) will not be set for request URL '%s'", header.Name, e.Request.URL))
+						default:
+							logger.DebugContext(ctx, fmt.Sprintf("scoped extra HTTP header '%s' (scoped) will not be set for request URL '%s'", header.Name, e.Request.URL))
 						}
 					}
 				}
 
 				if len(extraHttpHeadersToSet) > 0 {
-					logger.Debug(fmt.Sprintf("setting extra HTTP headers for request URL '%s': %+v", e.Request.URL, extraHttpHeadersToSet))
+					logger.DebugContext(ctx, fmt.Sprintf("setting extra HTTP headers for request URL '%s': %+v", e.Request.URL, extraHttpHeadersToSet))
 
 					originalHeaders := e.Request.Headers
 					headers := make(map[string]string)
@@ -129,7 +129,7 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, option
 						if ok {
 							headers[key] = strValue
 						} else {
-							logger.Error(fmt.Sprintf("ignoring header '%s' for URL '%s' since it cannot be cast to a string", key, e.Request.URL))
+							logger.ErrorContext(ctx, fmt.Sprintf("ignoring header '%s' for URL '%s' since it cannot be cast to a string", key, e.Request.URL))
 						}
 					}
 
@@ -152,7 +152,7 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, option
 
 				err = req.Do(executorCtx)
 				if err != nil {
-					logger.Error(fmt.Sprintf("continue request: %s", err))
+					logger.ErrorContext(ctx, fmt.Sprintf("continue request: %s", err))
 				}
 			}()
 		}
@@ -177,7 +177,7 @@ type eventResponseReceivedOptions struct {
 // https://github.com/gotenberg/gotenberg/issues/1021.
 func listenForEventResponseReceived(
 	ctx context.Context,
-	logger *zap.Logger,
+	logger *slog.Logger,
 	options eventResponseReceivedOptions,
 ) {
 	normalizedIgnoreDomains := normalizeDomains(options.ignoreResourceHttpStatusDomains)
@@ -197,10 +197,9 @@ func listenForEventResponseReceived(
 	}
 
 	chromedp.ListenTarget(ctx, func(ev any) {
-		switch ev := ev.(type) {
-		case *network.EventResponseReceived:
+		if ev, ok := ev.(*network.EventResponseReceived); ok {
 			if ev.Response.URL == options.mainPageUrl {
-				logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+				logger.DebugContext(ctx, fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
 
 				if slices.Contains(options.failOnHttpStatusCodes, ev.Response.Status) {
 					options.invalidHttpStatusCodeMu.Lock()
@@ -212,11 +211,11 @@ func listenForEventResponseReceived(
 				return
 			}
 
-			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for a resource: %+v", ev.Response))
+			logger.DebugContext(ctx, fmt.Sprintf("event EventResponseReceived fired for a resource: %+v", ev.Response))
 
 			if slices.Contains(options.failOnResourceOnHttpStatusCode, ev.Response.Status) {
 				if !shouldCheckResourceHttpStatusCode(ev.Response.URL, normalizedIgnoreDomains) {
-					logger.Debug(fmt.Sprintf("skip resource HTTP status code check for '%s' due to domain filtering", ev.Response.URL))
+					logger.DebugContext(ctx, fmt.Sprintf("skip resource HTTP status code check for '%s' due to domain filtering", ev.Response.URL))
 					return
 				}
 
@@ -318,11 +317,10 @@ type eventLoadingFailedOptions struct {
 // https://github.com/gotenberg/gotenberg/issues/913.
 // https://github.com/gotenberg/gotenberg/issues/959.
 // https://github.com/gotenberg/gotenberg/issues/1021.
-func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, options eventLoadingFailedOptions) {
+func listenForEventLoadingFailed(ctx context.Context, logger *slog.Logger, options eventLoadingFailedOptions) {
 	chromedp.ListenTarget(ctx, func(ev any) {
-		switch ev := ev.(type) {
-		case *network.EventLoadingFailed:
-			logger.Debug(fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
+		if ev, ok := ev.(*network.EventLoadingFailed); ok {
+			logger.DebugContext(ctx, fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
 
 			// We are looking for common errors.
 			// TODO: sufficient?
@@ -341,14 +339,14 @@ func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, option
 				"net::ERR_HTTP2_PROTOCOL_ERROR",
 			}
 			if !slices.Contains(errors, ev.ErrorText) {
-				logger.Debug(fmt.Sprintf("skip EventLoadingFailed: '%s' is not part of %+v", ev.ErrorText, errors))
+				logger.DebugContext(ctx, fmt.Sprintf("skip EventLoadingFailed: '%s' is not part of %+v", ev.ErrorText, errors))
 				return
 			}
 
 			if ev.Type == network.ResourceTypeDocument {
 				// Supposition: except iframe, an event loading failed with a
 				// resource type Document is about the main page.
-				logger.Debug("event EventLoadingFailed fired for main page")
+				logger.DebugContext(ctx, "event EventLoadingFailed fired for main page")
 
 				options.loadingFailedMu.Lock()
 				defer options.loadingFailedMu.Unlock()
@@ -358,7 +356,7 @@ func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, option
 				return
 			}
 
-			logger.Debug("event EventLoadingFailed fired for a resource")
+			logger.DebugContext(ctx, "event EventLoadingFailed fired for a resource")
 
 			options.resourceLoadingFailedMu.Lock()
 			defer options.resourceLoadingFailedMu.Unlock()
@@ -374,11 +372,10 @@ func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, option
 // listenForEventExceptionThrown listens for exceptions in the console and
 // appends those exceptions to the given error pointer.
 // See https://github.com/gotenberg/gotenberg/issues/262.
-func listenForEventExceptionThrown(ctx context.Context, logger *zap.Logger, consoleExceptions *error, consoleExceptionsMu *sync.RWMutex) {
+func listenForEventExceptionThrown(ctx context.Context, logger *slog.Logger, consoleExceptions *error, consoleExceptionsMu *sync.RWMutex) {
 	chromedp.ListenTarget(ctx, func(ev any) {
-		switch ev := ev.(type) {
-		case *runtime.EventExceptionThrown:
-			logger.Debug(fmt.Sprintf("event EventExceptionThrown fired: %+v", ev.ExceptionDetails))
+		if ev, ok := ev.(*runtime.EventExceptionThrown); ok {
+			logger.DebugContext(ctx, fmt.Sprintf("event EventExceptionThrown fired: %+v", ev.ExceptionDetails))
 
 			consoleExceptionsMu.Lock()
 			defer consoleExceptionsMu.Unlock()
@@ -390,13 +387,12 @@ func listenForEventExceptionThrown(ctx context.Context, logger *zap.Logger, cons
 
 // waitForEventDomContentEventFired waits until the event DomContentEventFired
 // is fired or the context timeout.
-func waitForEventDomContentEventFired(ctx context.Context, logger *zap.Logger) func() error {
+func waitForEventDomContentEventFired(ctx context.Context, logger *slog.Logger) func() error {
 	return func() error {
 		ch := make(chan struct{})
 		cctx, cancel := context.WithCancel(ctx)
 		chromedp.ListenTarget(cctx, func(ev any) {
-			switch ev.(type) {
-			case *page.EventDomContentEventFired:
+			if _, ok := ev.(*page.EventDomContentEventFired); ok {
 				cancel()
 				close(ch)
 			}
@@ -404,7 +400,7 @@ func waitForEventDomContentEventFired(ctx context.Context, logger *zap.Logger) f
 
 		select {
 		case <-ch:
-			logger.Debug("event DomContentEventFired fired")
+			logger.DebugContext(ctx, "event DomContentEventFired fired")
 			return nil
 		case <-ctx.Done():
 			return fmt.Errorf("wait for event DomContentEventFired: %w", ctx.Err())
@@ -414,13 +410,12 @@ func waitForEventDomContentEventFired(ctx context.Context, logger *zap.Logger) f
 
 // waitForEventLoadEventFired waits until the event LoadEventFired is fired or
 // the context timeout.
-func waitForEventLoadEventFired(ctx context.Context, logger *zap.Logger) func() error {
+func waitForEventLoadEventFired(ctx context.Context, logger *slog.Logger) func() error {
 	return func() error {
 		ch := make(chan struct{})
 		cctx, cancel := context.WithCancel(ctx)
 		chromedp.ListenTarget(cctx, func(ev any) {
-			switch ev.(type) {
-			case *page.EventLoadEventFired:
+			if _, ok := ev.(*page.EventLoadEventFired); ok {
 				cancel()
 				close(ch)
 			}
@@ -428,7 +423,7 @@ func waitForEventLoadEventFired(ctx context.Context, logger *zap.Logger) func()
 
 		select {
 		case <-ch:
-			logger.Debug("event LoadEventFired fired")
+			logger.DebugContext(ctx, "event LoadEventFired fired")
 			return nil
 		case <-ctx.Done():
 			return fmt.Errorf("wait for event LoadEventFired: %w", ctx.Err())
@@ -438,23 +433,20 @@ func waitForEventLoadEventFired(ctx context.Context, logger *zap.Logger) func()
 
 // waitForEventNetworkIdle waits until the event networkIdle is fired or the
 // context timeout.
-func waitForEventNetworkIdle(ctx context.Context, logger *zap.Logger) func() error {
+func waitForEventNetworkIdle(ctx context.Context, logger *slog.Logger) func() error {
 	return func() error {
 		ch := make(chan struct{})
 		cctx, cancel := context.WithCancel(ctx)
 		chromedp.ListenTarget(cctx, func(ev any) {
-			switch e := ev.(type) {
-			case *page.EventLifecycleEvent:
-				if e.Name == "networkIdle" {
-					cancel()
-					close(ch)
-				}
+			if e, ok := ev.(*page.EventLifecycleEvent); ok && e.Name == "networkIdle" {
+				cancel()
+				close(ch)
 			}
 		})
 
 		select {
 		case <-ch:
-			logger.Debug("event networkIdle fired")
+			logger.DebugContext(ctx, "event networkIdle fired")
 			return nil
 		case <-ctx.Done():
 			return fmt.Errorf("wait for event networkIdle: %w", ctx.Err())
@@ -469,12 +461,9 @@ func waitForEventNetworkAlmostIdle(ctx context.Context, logger *slog.Logger) fun
 		ch := make(chan struct{})
 		cctx, cancel := context.WithCancel(ctx)
 		chromedp.ListenTarget(cctx, func(ev any) {
-			switch e := ev.(type) {
-			case *page.EventLifecycleEvent:
-				if e.Name == "networkIdle2" {
-					cancel()
-					close(ch)
-				}
+			if e, ok := ev.(*page.EventLifecycleEvent); ok && e.Name == "networkIdle2" {
+				cancel()
+				close(ch)
 			}
 		})
 
@@ -490,13 +479,12 @@ func waitForEventNetworkAlmostIdle(ctx context.Context, logger *slog.Logger) fun
 
 // waitForEventLoadingFinished waits until the event LoadingFinished is fired
 // or the context timeout.
-func waitForEventLoadingFinished(ctx context.Context, logger *zap.Logger) func() error {
+func waitForEventLoadingFinished(ctx context.Context, logger *slog.Logger) func() error {
 	return func() error {
 		ch := make(chan struct{})
 		cctx, cancel := context.WithCancel(ctx)
 		chromedp.ListenTarget(cctx, func(ev any) {
-			switch ev.(type) {
-			case *network.EventLoadingFinished:
+			if _, ok := ev.(*network.EventLoadingFinished); ok {
 				cancel()
 				close(ch)
 			}
@@ -504,7 +492,7 @@ func waitForEventLoadingFinished(ctx context.Context, logger *zap.Logger) func()
 
 		select {
 		case <-ch:
-			logger.Debug("event LoadingFinished fired")
+			logger.DebugContext(ctx, "event LoadingFinished fired")
 			return nil
 		case <-ctx.Done():
 			return fmt.Errorf("wait for event LoadingFinished: %w", ctx.Err())

pkg/modules/chromium/mocks.go

@@ -2,38 +2,37 @@ package chromium
 
 import (
 	"context"
-
-	"go.uber.org/zap"
+	"log/slog"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 // ApiMock is a mock for the [Api] interface.
 type ApiMock struct {
-	PdfMock        func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
-	ScreenshotMock func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+	PdfMock        func(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error
+	ScreenshotMock func(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error
 }
 
-func (api *ApiMock) Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+func (api *ApiMock) Pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error {
 	return api.PdfMock(ctx, logger, url, outputPath, options)
 }
 
-func (api *ApiMock) Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+func (api *ApiMock) Screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error {
 	return api.ScreenshotMock(ctx, logger, url, outputPath, options)
 }
 
 // browserMock is a mock for the [browser] interface.
 type browserMock struct {
 	gotenberg.ProcessMock
-	pdfMock        func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
-	screenshotMock func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error
+	pdfMock        func(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error
+	screenshotMock func(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error
 }
 
-func (b *browserMock) pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+func (b *browserMock) pdf(ctx context.Context, logger *slog.Logger, url, outputPath string, options PdfOptions) error {
 	return b.pdfMock(ctx, logger, url, outputPath, options)
 }
 
-func (b *browserMock) screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+func (b *browserMock) screenshot(ctx context.Context, logger *slog.Logger, url, outputPath string, options ScreenshotOptions) error {
 	return b.screenshotMock(ctx, logger, url, outputPath, options)
 }
 

pkg/modules/chromium/routes.go

@@ -187,10 +187,8 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 							invalidScopeToken = true
 							break
 						}
-					} else {
-						if token != "" {
-							valueTokens = append(valueTokens, token)
-						}
+					} else if token != "" {
+						valueTokens = append(valueTokens, token)
 					}
 				}
 

pkg/modules/chromium/tasks.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"time"
 
@@ -13,16 +14,15 @@ import (
 	"github.com/chromedp/cdproto/network"
 	"github.com/chromedp/cdproto/page"
 	"github.com/chromedp/chromedp"
-	"go.uber.org/zap"
 )
 
-func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOptions) chromedp.ActionFunc {
+func printToPdfActionFunc(logger *slog.Logger, outputPath string, options PdfOptions) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		paperHeight := options.PaperHeight
 		pageRanges := options.PageRanges
 
 		if options.SinglePage {
-			logger.Debug("single page PDF")
+			logger.DebugContext(ctx, "single page PDF")
 
 			_, _, _, _, _, cssContentSize, err := page.GetLayoutMetrics().Do(ctx)
 			if err != nil {
@@ -56,11 +56,11 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 			options.FooterTemplate != DefaultPdfOptions().FooterTemplate
 
 		if !hasCustomHeaderFooter {
-			logger.Debug("no custom header nor footer")
+			logger.DebugContext(ctx, "no custom header nor footer")
 
 			printToPdf = printToPdf.WithDisplayHeaderFooter(false)
 		} else {
-			logger.Debug("with custom header and/or footer")
+			logger.DebugContext(ctx, "with custom header and/or footer")
 
 			printToPdf = printToPdf.
 				WithDisplayHeaderFooter(true).
@@ -68,7 +68,7 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 				WithFooterTemplate(options.FooterTemplate)
 		}
 
-		logger.Debug(fmt.Sprintf("print to PDF with: %+v", printToPdf))
+		logger.DebugContext(ctx, fmt.Sprintf("print to PDF with: %+v", printToPdf))
 
 		_, stream, err := printToPdf.Do(ctx)
 		if err != nil {
@@ -86,7 +86,7 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 		defer func() {
 			err = reader.Close()
 			if err != nil {
-				logger.Error(fmt.Sprintf("close reader: %s", err))
+				logger.ErrorContext(ctx, fmt.Sprintf("close reader: %s", err))
 			}
 		}()
 
@@ -98,7 +98,7 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 		defer func() {
 			err = file.Close()
 			if err != nil {
-				logger.Error(fmt.Sprintf("close output path: %s", err))
+				logger.ErrorContext(ctx, fmt.Sprintf("close output path: %s", err))
 			}
 		}()
 
@@ -113,7 +113,7 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 	}
 }
 
-func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options ScreenshotOptions) chromedp.ActionFunc {
+func captureScreenshotActionFunc(logger *slog.Logger, outputPath string, options ScreenshotOptions) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		captureScreenshot := page.CaptureScreenshot().
 			WithCaptureBeyondViewport(true).
@@ -134,7 +134,7 @@ func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options
 				WithQuality(int64(options.Quality))
 		}
 
-		logger.Debug(fmt.Sprintf("capture screenshot with: %+v", captureScreenshot))
+		logger.DebugContext(ctx, fmt.Sprintf("capture screenshot with: %+v", captureScreenshot))
 
 		buffer, err := captureScreenshot.Do(ctx)
 		if err != nil {
@@ -149,7 +149,7 @@ func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options
 		defer func() {
 			err = file.Close()
 			if err != nil {
-				logger.Error(fmt.Sprintf("close output path: %s", err))
+				logger.ErrorContext(ctx, fmt.Sprintf("close output path: %s", err))
 			}
 		}()
 
@@ -162,9 +162,9 @@ func captureScreenshotActionFunc(logger *zap.Logger, outputPath string, options
 	}
 }
 
-func setDeviceMetricsOverride(logger *zap.Logger, width, height int) chromedp.ActionFunc {
+func setDeviceMetricsOverride(logger *slog.Logger, width, height int) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
-		logger.Debug("set device metrics override")
+		logger.DebugContext(ctx, "set device metrics override")
 
 		err := emulation.SetDeviceMetricsOverride(int64(width), int64(height), 1.0, false).Do(ctx)
 		if err == nil {
@@ -175,15 +175,15 @@ func setDeviceMetricsOverride(logger *zap.Logger, width, height int) chromedp.Ac
 	}
 }
 
-func clearCacheActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
+func clearCacheActionFunc(logger *slog.Logger, clear bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		// See https://github.com/gotenberg/gotenberg/issues/753.
 		if !clear {
-			logger.Debug("cache not cleared")
+			logger.DebugContext(ctx, "cache not cleared")
 			return nil
 		}
 
-		logger.Debug("clear cache")
+		logger.DebugContext(ctx, "clear cache")
 
 		err := network.ClearBrowserCache().Do(ctx)
 		if err == nil {
@@ -194,15 +194,15 @@ func clearCacheActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
 	}
 }
 
-func clearCookiesActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc {
+func clearCookiesActionFunc(logger *slog.Logger, clear bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		// See https://github.com/gotenberg/gotenberg/issues/753.
 		if !clear {
-			logger.Debug("cookies not cleared")
+			logger.DebugContext(ctx, "cookies not cleared")
 			return nil
 		}
 
-		logger.Debug("clear cookies")
+		logger.DebugContext(ctx, "clear cookies")
 
 		err := network.ClearBrowserCookies().Do(ctx)
 		if err == nil {
@@ -213,15 +213,15 @@ func clearCookiesActionFunc(logger *zap.Logger, clear bool) chromedp.ActionFunc
 	}
 }
 
-func disableJavaScriptActionFunc(logger *zap.Logger, disable bool) chromedp.ActionFunc {
+func disableJavaScriptActionFunc(logger *slog.Logger, disable bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		// See https://github.com/gotenberg/gotenberg/issues/175.
 		if !disable {
-			logger.Debug("JavaScript not disabled")
+			logger.DebugContext(ctx, "JavaScript not disabled")
 			return nil
 		}
 
-		logger.Debug("disable JavaScript")
+		logger.DebugContext(ctx, "disable JavaScript")
 
 		err := emulation.SetScriptExecutionDisabled(true).Do(ctx)
 		if err == nil {
@@ -232,10 +232,10 @@ func disableJavaScriptActionFunc(logger *zap.Logger, disable bool) chromedp.Acti
 	}
 }
 
-func setCookiesActionFunc(logger *zap.Logger, cookies []Cookie) chromedp.ActionFunc {
+func setCookiesActionFunc(logger *slog.Logger, cookies []Cookie) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if len(cookies) == 0 {
-			logger.Debug("no cookies to set")
+			logger.DebugContext(ctx, "no cookies to set")
 			return nil
 		}
 
@@ -274,21 +274,21 @@ func setCookiesActionFunc(logger *zap.Logger, cookies []Cookie) chromedp.ActionF
 				return fmt.Errorf("set cookie %s: %w", cookiePretty(cookieParams), err)
 			}
 
-			logger.Debug(fmt.Sprintf("set cookie %s", cookiePretty(cookieParams)))
+			logger.DebugContext(ctx, fmt.Sprintf("set cookie %s", cookiePretty(cookieParams)))
 		}
 
 		return nil
 	}
 }
 
-func userAgentOverride(logger *zap.Logger, userAgent string) chromedp.ActionFunc {
+func userAgentOverride(logger *slog.Logger, userAgent string) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if len(userAgent) == 0 {
-			logger.Debug("no user agent override")
+			logger.DebugContext(ctx, "no user agent override")
 			return nil
 		}
 
-		logger.Debug(fmt.Sprintf("user agent override: %s", userAgent))
+		logger.DebugContext(ctx, fmt.Sprintf("user agent override: %s", userAgent))
 		err := emulation.SetUserAgentOverride(userAgent).Do(ctx)
 		if err == nil {
 			return nil
@@ -303,32 +303,32 @@ func userAgentOverride(logger *zap.Logger, userAgent string) chromedp.ActionFunc
 // network.SetExtraHTTPHeaders set the headers for ALL requests from the page.
 // See https://github.com/gotenberg/gotenberg/issues/1011.
 //
-//func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
-//	return func(ctx context.Context) error {
-//		if len(extraHttpHeaders) == 0 {
-//			logger.Debug("no extra HTTP headers")
-//			return nil
-//		}
+//  func extraHttpHeadersActionFunc(logger *slog.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
+// 	return func(ctx context.Context) error {
+// 		if len(extraHttpHeaders) == 0 {
+// 			logger.DebugContext(ctx,"no extra HTTP headers")
+// 			return nil
+// 		}
 //
-//		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
+// 		logger.DebugContext(ctx,fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
 //
-//		headers := make(network.Headers, len(extraHttpHeaders))
-//		for key, value := range extraHttpHeaders {
-//			headers[key] = value
-//		}
+// 		headers := make(network.Headers, len(extraHttpHeaders))
+// 		for key, value := range extraHttpHeaders {
+// 			headers[key] = value
+// 		}
 //
-//		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
-//		if err == nil {
-//			return nil
-//		}
+// 		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
+// 		if err == nil {
+// 			return nil
+// 		}
 //
-//		return fmt.Errorf("set extra HTTP headers: %w", err)
-//	}
-//}
+// 		return fmt.Errorf("set extra HTTP headers: %w", err)
+// 	}
+// }
 
-func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent, skipNetworkAlmostIdleEvent bool) chromedp.ActionFunc {
+func navigateActionFunc(logger *slog.Logger, url string, skipNetworkIdleEvent, skipNetworkAlmostIdleEvent bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
-		logger.Debug(fmt.Sprintf("navigate to '%s'", url))
+		logger.DebugContext(ctx, fmt.Sprintf("navigate to '%s'", url))
 
 		_, _, _, _, err := page.Navigate(url).Do(ctx)
 		if err != nil {
@@ -344,13 +344,13 @@ func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent, sk
 		if !skipNetworkIdleEvent {
 			waitFunc = append(waitFunc, waitForEventNetworkIdle(ctx, logger))
 		} else {
-			logger.Debug("skipping network idle event")
+			logger.DebugContext(ctx, "skipping network idle event")
 		}
 
 		if !skipNetworkAlmostIdleEvent {
 			waitFunc = append(waitFunc, waitForEventNetworkAlmostIdle(ctx, logger))
 		} else {
-			logger.Debug("skipping network almost idle event")
+			logger.DebugContext(ctx, "skipping network almost idle event")
 		}
 
 		err = runBatch(
@@ -366,11 +366,11 @@ func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent, sk
 	}
 }
 
-func hideDefaultWhiteBackgroundActionFunc(logger *zap.Logger, omitBackground, printBackground bool) chromedp.ActionFunc {
+func hideDefaultWhiteBackgroundActionFunc(logger *slog.Logger, omitBackground, printBackground bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		// See https://github.com/gotenberg/gotenberg/issues/226.
 		if !omitBackground {
-			logger.Debug("default white background not hidden")
+			logger.DebugContext(ctx, "default white background not hidden")
 			return nil
 		}
 
@@ -379,7 +379,7 @@ func hideDefaultWhiteBackgroundActionFunc(logger *zap.Logger, omitBackground, pr
 			return fmt.Errorf("validate omit background: %w", ErrOmitBackgroundWithoutPrintBackground)
 		}
 
-		logger.Debug("hide default white background")
+		logger.DebugContext(ctx, "hide default white background")
 
 		err := emulation.SetDefaultBackgroundColorOverride().WithColor(
 			&cdp.RGBA{
@@ -397,7 +397,7 @@ func hideDefaultWhiteBackgroundActionFunc(logger *zap.Logger, omitBackground, pr
 	}
 }
 
-func forceExactColorsActionFunc(logger *zap.Logger, printBackground bool) chromedp.ActionFunc {
+func forceExactColorsActionFunc(logger *slog.Logger, printBackground bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		css := "html { -webkit-print-color-adjust: exact !important; }"
 		if !printBackground {
@@ -405,7 +405,7 @@ func forceExactColorsActionFunc(logger *zap.Logger, printBackground bool) chrome
 			// print of the background, whatever the printToPDF args.
 			// See https://github.com/gotenberg/gotenberg/issues/1154.
 			additionalCss := "html, body { background: none !important; }"
-			logger.Debug(fmt.Sprintf("inject %s as printBackground is %t", additionalCss, printBackground))
+			logger.DebugContext(ctx, fmt.Sprintf("inject %s as printBackground is %t", additionalCss, printBackground))
 			css += additionalCss
 		}
 
@@ -429,10 +429,10 @@ func forceExactColorsActionFunc(logger *zap.Logger, printBackground bool) chrome
 	}
 }
 
-func emulateMediaTypeActionFunc(logger *zap.Logger, mediaType string, mediaFeatures []EmulatedMediaFeature) chromedp.ActionFunc {
+func emulateMediaTypeActionFunc(logger *slog.Logger, mediaType string, mediaFeatures []EmulatedMediaFeature) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if mediaType == "" && len(mediaFeatures) == 0 {
-			logger.Debug("no emulated media type or features")
+			logger.DebugContext(ctx, "no emulated media type or features")
 			return nil
 		}
 
@@ -443,12 +443,12 @@ func emulateMediaTypeActionFunc(logger *zap.Logger, mediaType string, mediaFeatu
 		emulatedMedia := emulation.SetEmulatedMedia()
 
 		if mediaType != "" {
-			logger.Debug(fmt.Sprintf("emulate media type '%s'", mediaType))
+			logger.DebugContext(ctx, fmt.Sprintf("emulate media type '%s'", mediaType))
 			emulatedMedia = emulatedMedia.WithMedia(mediaType)
 		}
 
 		if len(mediaFeatures) > 0 {
-			logger.Debug(fmt.Sprintf("emulate media features %+v", mediaFeatures))
+			logger.DebugContext(ctx, fmt.Sprintf("emulate media features %+v", mediaFeatures))
 
 			features := make([]*emulation.MediaFeature, len(mediaFeatures))
 			for i, f := range mediaFeatures {
@@ -470,21 +470,21 @@ func emulateMediaTypeActionFunc(logger *zap.Logger, mediaType string, mediaFeatu
 	}
 }
 
-func waitDelayBeforePrintActionFunc(logger *zap.Logger, disableJavaScript bool, delay time.Duration) chromedp.ActionFunc {
+func waitDelayBeforePrintActionFunc(logger *slog.Logger, disableJavaScript bool, delay time.Duration) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if disableJavaScript {
-			logger.Debug("JavaScript disabled, skipping wait delay")
+			logger.DebugContext(ctx, "JavaScript disabled, skipping wait delay")
 			return nil
 		}
 
 		if delay <= 0 {
-			logger.Debug("no wait delay")
+			logger.DebugContext(ctx, "no wait delay")
 			return nil
 		}
 
 		// We wait for a given amount of time so that JavaScript
 		// scripts have a chance to finish before printing the page.
-		logger.Debug(fmt.Sprintf("wait '%s' before print", delay))
+		logger.DebugContext(ctx, fmt.Sprintf("wait '%s' before print", delay))
 
 		select {
 		case <-ctx.Done():
@@ -495,21 +495,21 @@ func waitDelayBeforePrintActionFunc(logger *zap.Logger, disableJavaScript bool,
 	}
 }
 
-func waitForExpressionBeforePrintActionFunc(logger *zap.Logger, disableJavaScript bool, expression string) chromedp.ActionFunc {
+func waitForExpressionBeforePrintActionFunc(logger *slog.Logger, disableJavaScript bool, expression string) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if disableJavaScript {
-			logger.Debug("JavaScript disabled, skipping wait expression")
+			logger.DebugContext(ctx, "JavaScript disabled, skipping wait expression")
 			return nil
 		}
 
 		if expression == "" {
-			logger.Debug("no wait expression")
+			logger.DebugContext(ctx, "no wait expression")
 			return nil
 		}
 
 		// We wait until the evaluation of the expression is true or
 		// until the context is done.
-		logger.Debug(fmt.Sprintf("wait until '%s' is true before print", expression))
+		logger.DebugContext(ctx, fmt.Sprintf("wait until '%s' is true before print", expression))
 		ticker := time.NewTicker(time.Duration(100) * time.Millisecond)
 
 		for {
@@ -537,14 +537,14 @@ func waitForExpressionBeforePrintActionFunc(logger *zap.Logger, disableJavaScrip
 	}
 }
 
-func waitForSelectorVisibleBeforePrintActionFunc(logger *zap.Logger, selector string) chromedp.ActionFunc {
+func waitForSelectorVisibleBeforePrintActionFunc(logger *slog.Logger, selector string) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
 		if selector == "" {
-			logger.Debug("no wait selector")
+			logger.DebugContext(ctx, "no wait selector")
 			return nil
 		}
 
-		logger.Debug(fmt.Sprintf("wait until '%s' is visible before print", selector))
+		logger.DebugContext(ctx, fmt.Sprintf("wait until '%s' is visible before print", selector))
 		err := chromedp.WaitVisible(selector, chromedp.ByQuery, chromedp.RetryInterval(time.Duration(100)*time.Millisecond)).Do(ctx)
 		if err != nil {
 			return fmt.Errorf("wait visible: %v: %w", err, ErrInvalidSelectorQuery)

pkg/modules/exiftool/exiftool.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"reflect"
@@ -11,7 +12,6 @@ import (
 	"syscall"
 
 	"github.com/barasher/go-exiftool"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -74,27 +74,27 @@ func (engine *ExifTool) Debug() map[string]any {
 }
 
 // Merge is not available in this implementation.
-func (engine *ExifTool) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (engine *ExifTool) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
 	return fmt.Errorf("merge PDFs with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Split is not available in this implementation.
-func (engine *ExifTool) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (engine *ExifTool) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
 	return nil, fmt.Errorf("split PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Flatten is not available in this implementation.
-func (engine *ExifTool) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (engine *ExifTool) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
 	return fmt.Errorf("flatten PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Convert is not available in this implementation.
-func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (engine *ExifTool) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with ExifTool: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadMetadata extracts the metadata of a given PDF file.
-func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
 	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
 	if err != nil {
 		return nil, fmt.Errorf("new ExifTool: %w", err)
@@ -103,7 +103,7 @@ func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, in
 	defer func(exifTool *exiftool.Exiftool) {
 		err := exifTool.Close()
 		if err != nil {
-			logger.Error(fmt.Sprintf("close ExifTool: %v", err))
+			logger.ErrorContext(ctx, fmt.Sprintf("close ExifTool: %v", err))
 		}
 	}(exifTool)
 
@@ -116,7 +116,7 @@ func (engine *ExifTool) ReadMetadata(ctx context.Context, logger *zap.Logger, in
 }
 
 // WriteMetadata writes the metadata into a given PDF file.
-func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
 	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
 	if err != nil {
 		return fmt.Errorf("new ExifTool: %w", err)
@@ -125,7 +125,7 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 	defer func(exifTool *exiftool.Exiftool) {
 		err := exifTool.Close()
 		if err != nil {
-			logger.Error(fmt.Sprintf("close ExifTool: %v", err))
+			logger.ErrorContext(ctx, fmt.Sprintf("close ExifTool: %v", err))
 		}
 	}(exifTool)
 
@@ -204,7 +204,7 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 }
 
 // PageCount returns the number of pages in a PDF file using ExifTool.
-func (engine *ExifTool) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (engine *ExifTool) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
 	metadata, err := engine.ReadMetadata(ctx, logger, inputPath)
 	if err != nil {
 		return 0, fmt.Errorf("read metadata with ExifTool: %w", err)
@@ -235,37 +235,37 @@ func (engine *ExifTool) PageCount(ctx context.Context, logger *zap.Logger, input
 }
 
 // WriteBookmarks is not available in this implementation.
-func (engine *ExifTool) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (engine *ExifTool) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
 	return fmt.Errorf("write PDF bookmarks with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadBookmarks is not available in this implementation.
-func (engine *ExifTool) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+func (engine *ExifTool) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
 	return nil, fmt.Errorf("read PDF bookmarks with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Encrypt is not available in this implementation.
-func (engine *ExifTool) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (engine *ExifTool) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
 	return fmt.Errorf("encrypt PDF using ExifTool: %w", gotenberg.ErrPdfEncryptionNotSupported)
 }
 
 // EmbedFiles is not available in this implementation.
-func (engine *ExifTool) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+func (engine *ExifTool) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
 	return fmt.Errorf("embed files with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Watermark is not available in this implementation.
-func (engine *ExifTool) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *ExifTool) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("watermark PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Stamp is not available in this implementation.
-func (engine *ExifTool) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *ExifTool) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("stamp PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Rotate is not available in this implementation.
-func (engine *ExifTool) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (engine *ExifTool) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
 	return fmt.Errorf("rotate PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 

pkg/modules/libreoffice/api/api.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"strings"
@@ -12,8 +13,9 @@ import (
 
 	"github.com/alexliesenfeld/health"
 	flag "github.com/spf13/pflag"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
 	"go.uber.org/multierr"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
@@ -45,9 +47,15 @@ type Api struct {
 	autoStart bool
 	args      libreOfficeArguments
 
-	logger      *zap.Logger
+	logger      *slog.Logger
 	libreOffice libreOffice
 	supervisor  gotenberg.ProcessSupervisor
+
+	reqsCounter               metric.Int64Counter
+	errsCounter               metric.Int64Counter
+	conversionDurationCounter metric.Float64Histogram
+	queueWaitDurationCounter  metric.Float64Histogram
+	pdfOutputSizeCounter      metric.Int64Histogram
 }
 
 // Options gathers available options when converting a document to PDF.
@@ -216,7 +224,7 @@ func DefaultOptions() Options {
 
 // Uno is an abstraction on top of the Universal Network Objects API.
 type Uno interface {
-	Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	Pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error
 	Extensions() []string
 }
 
@@ -270,20 +278,108 @@ func (a *Api) Provision(ctx *gotenberg.Context) error {
 	}
 
 	// Logger.
-	loggerProvider, err := ctx.Module(new(gotenberg.LoggerProvider))
-	if err != nil {
-		return fmt.Errorf("get logger provider: %w", err)
-	}
-	logger, err := loggerProvider.(gotenberg.LoggerProvider).Logger(a)
-	if err != nil {
-		return fmt.Errorf("get logger: %w", err)
-	}
-	a.logger = logger.Named("libreoffice")
+	a.logger = gotenberg.Logger(a).With(slog.String("logger", "libreoffice"))
 
 	// Process.
 	a.libreOffice = newLibreOfficeProcess(a.args)
 	a.supervisor = gotenberg.NewProcessSupervisor(a.logger, a.libreOffice, flags.MustInt64("libreoffice-restart-after"), flags.MustInt64("libreoffice-max-queue-size"), 1)
 
+	// Metrics.
+	meter := gotenberg.Meter()
+
+	// Observable gauges.
+	var err error
+
+	_, err = meter.Int64ObservableGauge(
+		"libreoffice.requests.active",
+		metric.WithDescription("Current number of active LibreOffice requests"),
+		metric.WithUnit("{request}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(a.supervisor.ActiveTasksCount())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.requests.active gauge: %w", err)
+	}
+
+	_, err = meter.Int64ObservableGauge(
+		"libreoffice.requests.queue_size",
+		metric.WithDescription("Current number of LibreOffice conversion requests waiting to be treated"),
+		metric.WithUnit("{request}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(a.supervisor.ReqQueueSize())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.requests.queue_size gauge: %w", err)
+	}
+
+	_, err = meter.Int64ObservableCounter(
+		"libreoffice.process.restarts.total",
+		metric.WithDescription("Current number of LibreOffice restarts"),
+		metric.WithUnit("{restart}"),
+		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
+			o.Observe(a.supervisor.RestartsCount())
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.process.restarts.total counter: %w", err)
+	}
+
+	// Counters.
+	a.reqsCounter, err = meter.Int64Counter(
+		"libreoffice.requests.total",
+		metric.WithDescription("Total number of LibreOffice conversion requests"),
+		metric.WithUnit("{request}"),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.requests.total counter: %w", err)
+	}
+
+	a.errsCounter, err = meter.Int64Counter(
+		"libreoffice.errors.total",
+		metric.WithDescription("Total number of LibreOffice conversion errors"),
+		metric.WithUnit("{error}"),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.errors.total counter: %w", err)
+	}
+
+	// Histograms.
+	durationBuckets := metric.WithExplicitBucketBoundaries(0.5, 1, 2, 5, 10, 30, 60)
+
+	a.conversionDurationCounter, err = meter.Float64Histogram(
+		"libreoffice.conversion.duration",
+		metric.WithDescription("Duration of LibreOffice conversions"),
+		metric.WithUnit("s"),
+		durationBuckets,
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.conversion.duration histogram: %w", err)
+	}
+
+	a.queueWaitDurationCounter, err = meter.Float64Histogram(
+		"libreoffice.queue.wait.duration",
+		metric.WithDescription("Duration of waiting in queue for LibreOffice conversions"),
+		metric.WithUnit("s"),
+		durationBuckets,
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.queue.wait.duration histogram: %w", err)
+	}
+
+	a.pdfOutputSizeCounter, err = meter.Int64Histogram(
+		"libreoffice.pdf.output.size",
+		metric.WithDescription("Size of PDF output from LibreOffice conversions"),
+		metric.WithUnit("By"),
+	)
+	if err != nil {
+		return fmt.Errorf("create libreoffice.pdf.output.size histogram: %w", err)
+	}
+
 	return nil
 }
 
@@ -332,7 +428,7 @@ func (a *Api) StartupMessage() string {
 func (a *Api) Stop(ctx context.Context) error {
 	// Block until the context is done so that another module may gracefully
 	// stop before we do a shutdown.
-	a.logger.Debug("wait for the end of grace duration")
+	a.logger.DebugContext(ctx, "wait for the end of grace duration")
 
 	<-ctx.Done()
 
@@ -431,18 +527,64 @@ func (a *Api) LibreOffice() (Uno, error) {
 }
 
 // Pdf converts a document to PDF.
-func (a *Api) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+func (a *Api) Pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error {
+	start := time.Now()
+	var conversionStart time.Time
+
 	err := a.supervisor.Run(ctx, logger, func() error {
+		conversionStart = time.Now()
 		return a.libreOffice.pdf(ctx, logger, inputPath, outputPath, options)
 	})
 
+	// Determine status and error reason.
+	status := "success"
+	reason := ""
+
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			status = "timeout"
+			reason = "timeout"
+		case errors.Is(err, context.Canceled):
+			status = "error"
+			reason = "context_cancelled"
+		case errors.Is(err, gotenberg.ErrMaximumQueueSizeExceeded) || errors.Is(err, gotenberg.ErrProcessAlreadyRestarting):
+			status = "error"
+			reason = "libreoffice_unavailable"
+		default:
+			status = "error"
+			reason = "unknown"
+		}
+	}
+
+	// Record metrics.
+	attrs := metric.WithAttributes(attribute.String("status", status))
+	a.reqsCounter.Add(ctx, 1, attrs)
+
+	if reason != "" {
+		a.errsCounter.Add(ctx, 1, metric.WithAttributes(attribute.String("reason", reason)))
+	}
+
+	if !conversionStart.IsZero() {
+		queueWait := conversionStart.Sub(start).Seconds()
+		a.queueWaitDurationCounter.Record(ctx, queueWait, attrs)
+
+		conversionDuration := time.Since(conversionStart).Seconds()
+		a.conversionDurationCounter.Record(ctx, conversionDuration, attrs)
+	}
+
 	if err == nil {
+		stat, statErr := os.Stat(outputPath)
+		if statErr == nil {
+			a.pdfOutputSizeCounter.Record(ctx, stat.Size(), attrs)
+		}
+
 		return nil
 	}
 
 	// See https://github.com/gotenberg/gotenberg/issues/639.
 	if errors.Is(err, ErrCoreDumped) {
-		logger.Debug(fmt.Sprintf("got a '%s' error, retry conversion", err))
+		logger.DebugContext(ctx, fmt.Sprintf("got a '%s' error, retry conversion", err))
 		return a.Pdf(ctx, logger, inputPath, outputPath, options)
 	}
 

pkg/modules/libreoffice/api/freeport.go

@@ -1,14 +1,14 @@
 package api
 
 import (
+	"context"
 	"fmt"
+	"log/slog"
 	"net"
 	"strconv"
-
-	"go.uber.org/zap"
 )
 
-func freePort(logger *zap.Logger) (int, error) {
+func freePort(logger *slog.Logger) (int, error) {
 	netListener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		return 0, fmt.Errorf("listen on the local network address: %w", err)
@@ -16,7 +16,7 @@ func freePort(logger *zap.Logger) (int, error) {
 	defer func() {
 		err := netListener.Close()
 		if err != nil {
-			logger.Error(fmt.Sprintf("close network listener: %s", err.Error()))
+			logger.ErrorContext(context.Background(), fmt.Sprintf("close network listener: %s", err.Error()))
 		}
 	}()
 

pkg/modules/libreoffice/api/libreoffice.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net"
 	"os"
 	"strings"
@@ -11,14 +12,12 @@ import (
 	"sync/atomic"
 	"time"
 
-	"go.uber.org/zap"
-
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 type libreOffice interface {
 	gotenberg.Process
-	pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error
 }
 
 type libreOfficeArguments struct {
@@ -48,7 +47,7 @@ func newLibreOfficeProcess(arguments libreOfficeArguments) libreOffice {
 	return p
 }
 
-func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
+func (p *libreOfficeProcess) Start(logger *slog.Logger) error {
 	if p.isStarted.Load() {
 		return errors.New("LibreOffice is already started")
 	}
@@ -86,7 +85,7 @@ func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
 		return fmt.Errorf("execute LibreOffice: %w", err)
 	}
 
-	logger.Debug("got exit code 81, e.g., LibreOffice first start")
+	logger.DebugContext(context.Background(), "got exit code 81, e.g., LibreOffice first start")
 
 	// Second start (daemon).
 	cmd = gotenberg.Command(logger, p.arguments.binPath, args...)
@@ -123,7 +122,7 @@ func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
 			connChan <- nil
 			err = conn.Close()
 			if err != nil {
-				logger.Debug(fmt.Sprintf("close connection after health checking the LibreOffice: %v", err))
+				logger.DebugContext(context.Background(), fmt.Sprintf("close connection after health checking the LibreOffice: %v", err))
 			}
 
 			break
@@ -148,19 +147,19 @@ func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
 		// Let's make sure the process is killed.
 		err = cmd.Kill()
 		if err != nil {
-			logger.Debug(fmt.Sprintf("kill LibreOffice process: %v", err))
+			logger.DebugContext(context.Background(), fmt.Sprintf("kill LibreOffice process: %v", err))
 		}
 
 		// And the user profile directory is deleted.
 		err = os.RemoveAll(userProfileDirPath)
 		if err != nil {
-			logger.Error(fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
+			logger.ErrorContext(context.Background(), fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
 		}
 
-		logger.Debug(fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
+		logger.DebugContext(context.Background(), fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
 	}()
 
-	logger.Debug("waiting for the LibreOffice socket to be available...")
+	logger.DebugContext(context.Background(), "waiting for the LibreOffice socket to be available...")
 
 	for {
 		select {
@@ -169,7 +168,7 @@ func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
 				return fmt.Errorf("LibreOffice socket not available: %w", err)
 			}
 
-			logger.Debug("LibreOffice socket available")
+			logger.DebugContext(context.Background(), "LibreOffice socket available")
 			success = true
 
 			return nil
@@ -179,7 +178,7 @@ func (p *libreOfficeProcess) Start(logger *zap.Logger) error {
 	}
 }
 
-func (p *libreOfficeProcess) Stop(logger *zap.Logger) error {
+func (p *libreOfficeProcess) Stop(logger *slog.Logger) error {
 	if !p.isStarted.Load() {
 		// No big deal? Like calling cancel twice.
 		return nil
@@ -192,15 +191,15 @@ func (p *libreOfficeProcess) Stop(logger *zap.Logger) error {
 		go func() {
 			err := os.RemoveAll(userProfileDirPath)
 			if err != nil {
-				logger.Error(fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
+				logger.ErrorContext(context.Background(), fmt.Sprintf("remove LibreOffice's user profile directory: %v", err))
 			} else {
-				logger.Debug(fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
+				logger.DebugContext(context.Background(), fmt.Sprintf("'%s' LibreOffice's user profile directory removed", userProfileDirPath))
 			}
 
 			// Also, remove LibreOffice specific files in the temporary directory.
-			err = gotenberg.GarbageCollect(logger, os.TempDir(), []string{"OSL_PIPE", ".tmp"}, expirationTime)
+			err = gotenberg.GarbageCollect(context.Background(), logger, os.TempDir(), []string{"OSL_PIPE", ".tmp"}, expirationTime)
 			if err != nil {
-				logger.Error(err.Error())
+				logger.ErrorContext(context.Background(), err.Error())
 			}
 		}()
 	}(copyUserProfileDirPath, expirationTime)
@@ -221,7 +220,7 @@ func (p *libreOfficeProcess) Stop(logger *zap.Logger) error {
 	return nil
 }
 
-func (p *libreOfficeProcess) Healthy(logger *zap.Logger) bool {
+func (p *libreOfficeProcess) Healthy(logger *slog.Logger) bool {
 	// Good to know: the supervisor does not call this method if no first start
 	// or if the process is restarting.
 
@@ -237,7 +236,7 @@ func (p *libreOfficeProcess) Healthy(logger *zap.Logger) bool {
 	if err == nil {
 		err = conn.Close()
 		if err != nil {
-			logger.Debug(fmt.Sprintf("close connection after health checking LibreOffice: %v", err))
+			logger.DebugContext(context.Background(), fmt.Sprintf("close connection after health checking LibreOffice: %v", err))
 		}
 
 		return true
@@ -246,7 +245,7 @@ func (p *libreOfficeProcess) Healthy(logger *zap.Logger) bool {
 	return false
 }
 
-func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+func (p *libreOfficeProcess) pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error {
 	if !p.isStarted.Load() {
 		return errors.New("LibreOffice not started, cannot handle PDF conversion")
 	}
@@ -259,8 +258,7 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 
 	args = append(args, "--port", fmt.Sprintf("%d", p.socketPort))
 
-	checkedEntry := logger.Check(zap.DebugLevel, "check for debug level before setting high verbosity")
-	if checkedEntry != nil {
+	if logger.Enabled(ctx, slog.LevelDebug) {
 		args = append(args, "-vvv")
 	}
 
@@ -362,7 +360,7 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 		return fmt.Errorf("create uno command: %w", err)
 	}
 
-	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
+	logger.DebugContext(ctx, fmt.Sprintf("print to PDF with: %+v", options))
 
 	exitCode, err := cmd.Exec()
 	if err == nil {

pkg/modules/libreoffice/api/mocks.go

@@ -3,19 +3,18 @@ package api
 import (
 	"context"
 	"errors"
-
-	"go.uber.org/zap"
+	"log/slog"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 // ApiMock is a mock for the [Uno] interface.
 type ApiMock struct {
-	PdfMock        func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	PdfMock        func(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error
 	ExtensionsMock func() []string
 }
 
-func (api *ApiMock) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+func (api *ApiMock) Pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error {
 	return api.PdfMock(ctx, logger, inputPath, outputPath, options)
 }
 
@@ -37,10 +36,10 @@ type libreOfficeMock struct {
 	errCoreDumpedCount int
 
 	gotenberg.ProcessMock
-	pdfMock func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
+	pdfMock func(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error
 }
 
-func (b *libreOfficeMock) pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
+func (b *libreOfficeMock) pdf(ctx context.Context, logger *slog.Logger, inputPath, outputPath string, options Options) error {
 	err := b.pdfMock(ctx, logger, inputPath, outputPath, options)
 	if errors.Is(err, ErrCoreDumped) {
 		b.errCoreDumpedCount += 1

pkg/modules/libreoffice/pdfengine/pdfengine.go

@@ -4,8 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
-
-	"go.uber.org/zap"
+	"log/slog"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
@@ -47,17 +46,17 @@ func (engine *LibreOfficePdfEngine) Provision(ctx *gotenberg.Context) error {
 }
 
 // Merge is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
 	return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Split is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (engine *LibreOfficePdfEngine) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
 	return nil, fmt.Errorf("split PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Flatten is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (engine *LibreOfficePdfEngine) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
 	return fmt.Errorf("flatten PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
@@ -65,7 +64,7 @@ func (engine *LibreOfficePdfEngine) Flatten(ctx context.Context, logger *zap.Log
 // PDF/A-1b, PDF/A-2b, PDF/A-3b and PDF/UA formats are available. If another
 // PDF format is requested, it returns a [gotenberg.ErrPdfFormatNotSupported]
 // error.
-func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	opts := api.DefaultOptions()
 	opts.PdfFormats = formats
 	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, opts)
@@ -82,52 +81,52 @@ func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Log
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
 	return nil, fmt.Errorf("read PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
 	return fmt.Errorf("write PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // PageCount is not available in this implementation.
-func (engine *LibreOfficePdfEngine) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (engine *LibreOfficePdfEngine) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
 	return 0, fmt.Errorf("page count with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteBookmarks is not available in this implementation.
-func (engine *LibreOfficePdfEngine) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (engine *LibreOfficePdfEngine) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
 	return fmt.Errorf("write PDF bookmarks with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadBookmarks is not available in this implementation.
-func (engine *LibreOfficePdfEngine) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+func (engine *LibreOfficePdfEngine) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
 	return nil, fmt.Errorf("read PDF bookmarks with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Encrypt is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (engine *LibreOfficePdfEngine) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
 	return fmt.Errorf("encrypt PDF using LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // EmbedFiles is not available in this implementation.
-func (engine *LibreOfficePdfEngine) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+func (engine *LibreOfficePdfEngine) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
 	return fmt.Errorf("embed files with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Watermark is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *LibreOfficePdfEngine) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("watermark PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Stamp is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *LibreOfficePdfEngine) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("stamp PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Rotate is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (engine *LibreOfficePdfEngine) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
 	return fmt.Errorf("rotate PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 

pkg/modules/logging/color.go

@@ -1,49 +0,0 @@
-package logging
-
-import (
-	"fmt"
-
-	"go.uber.org/zap/zapcore"
-)
-
-// Foreground colors.
-// Copy pasted from go.uber.org/zap/internal/color/color.go
-const (
-	black color = iota + 30
-	red
-	green
-	yellow
-	blue
-	magenta
-	cyan
-	white
-)
-
-type color uint8
-
-func (c color) Add(s string) string {
-	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(c), s)
-}
-
-func levelToColor(l zapcore.Level) color {
-	switch l {
-	case zapcore.DebugLevel:
-		return cyan
-	case zapcore.InfoLevel:
-		return blue
-	case zapcore.WarnLevel:
-		return yellow
-	case zapcore.ErrorLevel:
-		return red
-	case zapcore.DPanicLevel:
-		return red
-	case zapcore.PanicLevel:
-		return red
-	case zapcore.FatalLevel:
-		return red
-	case zapcore.InvalidLevel:
-		return red
-	default:
-		return red
-	}
-}

pkg/modules/logging/doc.go

@@ -1,3 +0,0 @@
-// Package logging provides a module which creates a zap.Logger instance for
-// other modules.
-package logging

pkg/modules/logging/gcp.go

@@ -1,36 +0,0 @@
-package logging
-
-import "go.uber.org/zap/zapcore"
-
-func gcpSeverity(l zapcore.Level) string {
-	switch l {
-	case zapcore.DebugLevel:
-		return "DEBUG"
-	case zapcore.InfoLevel:
-		return "INFO"
-	case zapcore.WarnLevel:
-		return "WARNING"
-	case zapcore.ErrorLevel:
-		return "ERROR"
-	case zapcore.DPanicLevel:
-		return "CRITICAL"
-	case zapcore.PanicLevel:
-		return "ALERT"
-	case zapcore.FatalLevel:
-		return "EMERGENCY"
-	case zapcore.InvalidLevel:
-		return "DEFAULT"
-	default:
-		return "DEFAULT"
-	}
-}
-
-func gcpSeverityEncoder(l zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
-	enc.AppendString(gcpSeverity(l))
-}
-
-func gcpSeverityColorEncoder(l zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
-	severity := gcpSeverity(l)
-	c := levelToColor(l)
-	enc.AppendString(c.Add(severity))
-}

pkg/modules/logging/logging.go

@@ -1,239 +0,0 @@
-package logging
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	flag "github.com/spf13/pflag"
-	"go.uber.org/multierr"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-	"golang.org/x/term"
-
-	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
-)
-
-func init() {
-	gotenberg.MustRegisterModule(new(Logging))
-}
-
-const (
-	errorLoggingLevel = "error"
-	warnLoggingLevel  = "warn"
-	infoLoggingLevel  = "info"
-	debugLoggingLevel = "debug"
-)
-
-const (
-	autoLoggingFormat = "auto"
-	jsonLoggingFormat = "json"
-	textLoggingFormat = "text"
-)
-
-// Logging is a module that implements the [gotenberg.LoggerProvider]
-// interface.
-type Logging struct {
-	level           string
-	format          string
-	fieldsPrefix    string
-	enableGcpFields bool
-}
-
-// Descriptor returns a [Logging]'s module descriptor.
-func (log *Logging) Descriptor() gotenberg.ModuleDescriptor {
-	return gotenberg.ModuleDescriptor{
-		ID: "logging",
-		FlagSet: func() *flag.FlagSet {
-			fs := flag.NewFlagSet("logging", flag.ExitOnError)
-			fs.String("log-level", infoLoggingLevel, fmt.Sprintf("Choose the level of logging detail. Options include %s, %s, %s, or %s", errorLoggingLevel, warnLoggingLevel, infoLoggingLevel, debugLoggingLevel))
-			fs.String("log-format", autoLoggingFormat, fmt.Sprintf("Specify the format of logging. Options include %s, %s, or %s", autoLoggingFormat, jsonLoggingFormat, textLoggingFormat))
-			fs.String("log-fields-prefix", "", "Prepend a specified prefix to each field in the logs")
-			fs.Bool("log-enable-gcp-fields", false, "Enable Google Cloud Platform fields - namely: time, message, severity")
-
-			// Deprecated flags.
-			fs.Bool("log-enable-gcp-severity", false, "Enable Google Cloud Platform severity mapping")
-			err := fs.MarkDeprecated("log-enable-gcp-severity", "use log-enable-gcp-fields instead")
-			if err != nil {
-				panic(err)
-			}
-
-			return fs
-		}(),
-		New: func() gotenberg.Module { return new(Logging) },
-	}
-}
-
-// Provision sets the log level and format.
-func (log *Logging) Provision(ctx *gotenberg.Context) error {
-	flags := ctx.ParsedFlags()
-
-	log.level = flags.MustString("log-level")
-	log.format = flags.MustString("log-format")
-	log.fieldsPrefix = flags.MustString("log-fields-prefix")
-	log.enableGcpFields = flags.MustDeprecatedBool("log-enable-gcp-severity", "log-enable-gcp-fields")
-
-	return nil
-}
-
-// Validate validates the log level and format.
-func (log *Logging) Validate() error {
-	var err error
-
-	switch log.level {
-	case errorLoggingLevel, warnLoggingLevel, infoLoggingLevel, debugLoggingLevel:
-		break
-	default:
-		err = multierr.Append(
-			err,
-			fmt.Errorf("log level must be either %s, %s, %s or %s", errorLoggingLevel, warnLoggingLevel, infoLoggingLevel, debugLoggingLevel),
-		)
-	}
-
-	switch log.format {
-	case autoLoggingFormat, jsonLoggingFormat, textLoggingFormat:
-		break
-	default:
-		err = multierr.Append(
-			err,
-			fmt.Errorf("log format must be either %s, %s or %s", autoLoggingFormat, jsonLoggingFormat, textLoggingFormat),
-		)
-	}
-
-	return err
-}
-
-// Logger returns a [zap.Logger].
-func (log *Logging) Logger(mod gotenberg.Module) (*zap.Logger, error) {
-	if logger == nil {
-		lvl, err := newLogLevel(log.level)
-		if err != nil {
-			return nil, fmt.Errorf("get log level: %w", err)
-		}
-
-		encoder, err := newLogEncoder(log.format, log.enableGcpFields)
-		if err != nil {
-			return nil, fmt.Errorf("get log encoder: %w", err)
-		}
-
-		logger = zap.New(customCore{
-			Core:         zapcore.NewCore(encoder, os.Stderr, lvl),
-			fieldsPrefix: log.fieldsPrefix,
-		})
-	}
-
-	return logger.Named(mod.Descriptor().ID), nil
-}
-
-// See https://github.com/gotenberg/gotenberg/issues/659.
-type customCore struct {
-	zapcore.Core
-	fieldsPrefix string
-}
-
-func (c customCore) With(fields []zapcore.Field) zapcore.Core {
-	if c.fieldsPrefix != "" {
-		for i := range fields {
-			fields[i].Key = c.fieldsPrefix + "_" + fields[i].Key
-		}
-	}
-
-	return customCore{
-		Core:         c.Core.With(fields),
-		fieldsPrefix: c.fieldsPrefix,
-	}
-}
-
-func (c customCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
-	// This is a copy from the zapcore.ioCore implementation. Indeed, by doing
-	// so, we are able to prefix the fields given to the logger methods like
-	// Debug, Info, Warn, Error, etc.
-	if c.Enabled(ent.Level) {
-		return ce.AddCore(ent, c)
-	}
-
-	return ce
-}
-
-func (c customCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
-	if c.fieldsPrefix != "" {
-		for i := range fields {
-			fields[i].Key = c.fieldsPrefix + "_" + fields[i].Key
-		}
-	}
-
-	return c.Core.Write(entry, fields)
-}
-
-func newLogLevel(level string) (zapcore.Level, error) {
-	lvl := zapcore.InvalidLevel
-
-	err := lvl.UnmarshalText([]byte(level))
-	if err != nil {
-		return lvl, fmt.Errorf("%q is not a recognized log level: %w", level, err)
-	}
-
-	return lvl, nil
-}
-
-func newLogEncoder(format string, gcpFields bool) (zapcore.Encoder, error) {
-	isTerminal := term.IsTerminal(int(os.Stdout.Fd())) // #nosec
-	encCfg := zap.NewProductionEncoderConfig()
-
-	// Normalize the log format based on the output device.
-	if format == autoLoggingFormat {
-		if isTerminal {
-			format = textLoggingFormat
-		} else {
-			format = jsonLoggingFormat
-		}
-	}
-
-	// Use a human-readable time format if running in a terminal.
-	if isTerminal {
-		encCfg.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) {
-			encoder.AppendString(ts.Local().Format("2006/01/02 15:04:05.000"))
-		}
-	}
-
-	// Configure level encoding based on format and GCP settings.
-	if format == textLoggingFormat && isTerminal {
-		if gcpFields {
-			encCfg.EncodeLevel = gcpSeverityColorEncoder
-		} else {
-			encCfg.EncodeLevel = zapcore.CapitalColorLevelEncoder
-		}
-	}
-
-	// For non-text (JSON) or when GCP fields are requested outside a terminal text output,
-	// adjust the configuration to use GCP-specific field names and encoders.
-	if gcpFields && format != textLoggingFormat {
-		encCfg.EncodeLevel = gcpSeverityEncoder
-		encCfg.TimeKey = "time"
-		encCfg.LevelKey = "severity"
-		encCfg.MessageKey = "message"
-		encCfg.EncodeTime = zapcore.ISO8601TimeEncoder
-		encCfg.EncodeDuration = zapcore.MillisDurationEncoder
-	}
-
-	switch format {
-	case textLoggingFormat:
-		return zapcore.NewConsoleEncoder(encCfg), nil
-	case jsonLoggingFormat:
-		return zapcore.NewJSONEncoder(encCfg), nil
-	default:
-		return nil, fmt.Errorf("%s is not a recognized log format", format)
-	}
-}
-
-// Singleton so that we instantiate our logger only once.
-var logger *zap.Logger = nil
-
-// Interface guards.
-var (
-	_ gotenberg.Module         = (*Logging)(nil)
-	_ gotenberg.Provisioner    = (*Logging)(nil)
-	_ gotenberg.Validator      = (*Logging)(nil)
-	_ gotenberg.LoggerProvider = (*Logging)(nil)
-	_ zapcore.Core             = (*customCore)(nil)
-)

pkg/modules/pdfcpu/pdfcpu.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -14,8 +15,6 @@ import (
 	"strings"
 	"syscall"
 
-	"go.uber.org/zap"
-
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
@@ -96,7 +95,7 @@ func (engine *PdfCpu) Debug() map[string]any {
 }
 
 // Merge combines multiple PDFs into a single PDF.
-func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (engine *PdfCpu) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
 	args := make([]string, 0, 2+len(inputPaths))
 	args = append(args, "merge", outputPath)
 	args = append(args, inputPaths...)
@@ -115,7 +114,7 @@ func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths
 }
 
 // Split splits a given PDF file.
-func (engine *PdfCpu) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (engine *PdfCpu) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
 	var args []string
 
 	switch mode.Mode {
@@ -165,32 +164,32 @@ func (engine *PdfCpu) Split(ctx context.Context, logger *zap.Logger, mode gotenb
 }
 
 // Flatten is not available in this implementation.
-func (engine *PdfCpu) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (engine *PdfCpu) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
 	return fmt.Errorf("flatten PDF with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Convert is not available in this implementation.
-func (engine *PdfCpu) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (engine *PdfCpu) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with pdfcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
 	return nil, fmt.Errorf("read PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
 	return fmt.Errorf("write PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // PageCount is not available in this implementation.
-func (engine *PdfCpu) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (engine *PdfCpu) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
 	return 0, fmt.Errorf("page count with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadBookmarks reads the document outline (bookmarks) of a PDF file using pdfcpu.
-func (engine *PdfCpu) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+func (engine *PdfCpu) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
 	tmpPath := fmt.Sprintf("%s.read.json", inputPath)
 	args := []string{"bookmarks", "export", inputPath, tmpPath}
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
@@ -201,7 +200,7 @@ func (engine *PdfCpu) ReadBookmarks(ctx context.Context, logger *zap.Logger, inp
 	defer func() {
 		err := os.Remove(tmpPath)
 		if err != nil && !os.IsNotExist(err) {
-			logger.Error(fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
+			logger.ErrorContext(ctx, fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
 		}
 	}()
 
@@ -269,7 +268,7 @@ func (engine *PdfCpu) ReadBookmarks(ctx context.Context, logger *zap.Logger, inp
 }
 
 // WriteBookmarks adds a document outline (bookmarks) to a PDF file using pdfcpu.
-func (engine *PdfCpu) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (engine *PdfCpu) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
 	if len(bookmarks) == 0 {
 		return nil
 	}
@@ -305,7 +304,7 @@ func (engine *PdfCpu) WriteBookmarks(ctx context.Context, logger *zap.Logger, in
 	defer func() {
 		err := os.Remove(tmpPath)
 		if err != nil {
-			logger.Error(fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
+			logger.ErrorContext(ctx, fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
 		}
 	}()
 
@@ -325,12 +324,12 @@ func (engine *PdfCpu) WriteBookmarks(ctx context.Context, logger *zap.Logger, in
 
 // EmbedFiles embeds files into a PDF. All files are embedded as file attachments
 // without modifying the main PDF content.
-func (engine *PdfCpu) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+func (engine *PdfCpu) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
 	if len(filePaths) == 0 {
 		return nil
 	}
 
-	logger.Debug(fmt.Sprintf("embedding %d file(s) to %s: %v", len(filePaths), inputPath, filePaths))
+	logger.DebugContext(ctx, fmt.Sprintf("embedding %d file(s) to %s: %v", len(filePaths), inputPath, filePaths))
 
 	args := make([]string, 0, 3+len(filePaths))
 	args = append(args, "attachments", "add", inputPath)
@@ -350,7 +349,7 @@ func (engine *PdfCpu) EmbedFiles(ctx context.Context, logger *zap.Logger, filePa
 }
 
 // Encrypt adds password protection to a PDF file using pdfcpu.
-func (engine *PdfCpu) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (engine *PdfCpu) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
 	if userPassword == "" {
 		return errors.New("user password cannot be empty")
 	}
@@ -381,17 +380,17 @@ func (engine *PdfCpu) Encrypt(ctx context.Context, logger *zap.Logger, inputPath
 }
 
 // Watermark applies a watermark (behind page content) to a PDF file using pdfcpu.
-func (engine *PdfCpu) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *PdfCpu) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return engine.applyStampOrWatermark(ctx, logger, "watermark", inputPath, stamp)
 }
 
 // Stamp applies a stamp (on top of page content) to a PDF file using pdfcpu.
-func (engine *PdfCpu) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *PdfCpu) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return engine.applyStampOrWatermark(ctx, logger, "stamp", inputPath, stamp)
 }
 
 // Rotate rotates pages of a PDF file by the given angle using pdfcpu.
-func (engine *PdfCpu) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (engine *PdfCpu) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
 	args := []string{"rotate"}
 	if pages != "" {
 		args = append(args, "-pages", pages)
@@ -411,7 +410,7 @@ func (engine *PdfCpu) Rotate(ctx context.Context, logger *zap.Logger, inputPath
 	return nil
 }
 
-func (engine *PdfCpu) applyStampOrWatermark(ctx context.Context, logger *zap.Logger, command string, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *PdfCpu) applyStampOrWatermark(ctx context.Context, logger *slog.Logger, command string, inputPath string, stamp gotenberg.Stamp) error {
 	var mode string
 	switch stamp.Source {
 	case gotenberg.StampSourceText:

pkg/modules/pdfengines/multi.go

@@ -3,10 +3,12 @@ package pdfengines
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"sync"
 
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/multierr"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -61,7 +63,13 @@ func newMultiPdfEngines(
 
 // Merge combines multiple PDF files into a single document using the first
 // available engine that supports PDF merging.
-func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -74,6 +82,7 @@ func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inp
 		case mergeErr := <-errChan:
 			errored := multierr.AppendInto(&err, mergeErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -81,7 +90,11 @@ func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inp
 		}
 	}
 
-	return fmt.Errorf("merge PDFs with multi PDF engines: %w", err)
+	err = fmt.Errorf("merge PDFs with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 type splitResult struct {
@@ -91,7 +104,11 @@ type splitResult struct {
 
 // Split divides the PDF into separate pages using the first available engine
 // that supports PDF splitting.
-func (multi *multiPdfEngines) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (multi *multiPdfEngines) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -110,6 +127,7 @@ func (multi *multiPdfEngines) Split(ctx context.Context, logger *zap.Logger, mod
 				err = multierr.Append(err, result.err)
 				mu.Unlock()
 			} else {
+				span.SetStatus(codes.Ok, "")
 				return result.outputPaths, nil
 			}
 		case <-ctx.Done():
@@ -117,12 +135,20 @@ func (multi *multiPdfEngines) Split(ctx context.Context, logger *zap.Logger, mod
 		}
 	}
 
-	return nil, fmt.Errorf("split PDF with multi PDF engines: %w", err)
+	err = fmt.Errorf("split PDF with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return nil, err
 }
 
 // Flatten merges existing annotation appearances with page content using the
 // first available engine that supports flattening.
-func (multi *multiPdfEngines) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (multi *multiPdfEngines) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -135,6 +161,7 @@ func (multi *multiPdfEngines) Flatten(ctx context.Context, logger *zap.Logger, i
 		case mergeErr := <-errChan:
 			errored := multierr.AppendInto(&err, mergeErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -142,12 +169,20 @@ func (multi *multiPdfEngines) Flatten(ctx context.Context, logger *zap.Logger, i
 		}
 	}
 
-	return fmt.Errorf("flatten PDF with multi PDF engines: %w", err)
+	err = fmt.Errorf("flatten PDF with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Convert transforms the given PDF to a specific PDF format using the first
 // available engine that supports PDF conversion.
-func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (multi *multiPdfEngines) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -160,6 +195,7 @@ func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, f
 		case mergeErr := <-errChan:
 			errored := multierr.AppendInto(&err, mergeErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -167,7 +203,11 @@ func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, f
 		}
 	}
 
-	return fmt.Errorf("convert PDF to '%+v' with multi PDF engines: %w", formats, err)
+	err = fmt.Errorf("convert PDF to '%+v' with multi PDF engines: %w", formats, err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 type readMetadataResult struct {
@@ -177,7 +217,13 @@ type readMetadataResult struct {
 
 // ReadMetadata extracts metadata from a PDF file using the first available
 // engine that supports metadata reading.
-func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -196,6 +242,7 @@ func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logg
 				err = multierr.Append(err, result.err)
 				mu.Unlock()
 			} else {
+				span.SetStatus(codes.Ok, "")
 				return result.metadata, nil
 			}
 		case <-ctx.Done():
@@ -203,12 +250,20 @@ func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logg
 		}
 	}
 
-	return nil, fmt.Errorf("read PDF metadata with multi PDF engines: %w", err)
+	err = fmt.Errorf("read PDF metadata with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return nil, err
 }
 
 // WriteMetadata embeds metadata into a PDF file using the first available
 // engine that supports metadata writing.
-func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -221,6 +276,7 @@ func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Log
 		case writeMetadataErr := <-errChan:
 			errored := multierr.AppendInto(&err, writeMetadataErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -228,7 +284,11 @@ func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Log
 		}
 	}
 
-	return fmt.Errorf("write PDF metadata with multi PDF engines: %w", err)
+	err = fmt.Errorf("write PDF metadata with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 type pageCountResult struct {
@@ -238,7 +298,11 @@ type pageCountResult struct {
 
 // PageCount returns the number of pages in a PDF file using the first available
 // engine that supports metadata reading.
-func (multi *multiPdfEngines) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (multi *multiPdfEngines) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.PageCount", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -257,6 +321,7 @@ func (multi *multiPdfEngines) PageCount(ctx context.Context, logger *zap.Logger,
 				err = multierr.Append(err, result.err)
 				mu.Unlock()
 			} else {
+				span.SetStatus(codes.Ok, "")
 				return result.pageCount, nil
 			}
 		case <-ctx.Done():
@@ -264,7 +329,11 @@ func (multi *multiPdfEngines) PageCount(ctx context.Context, logger *zap.Logger,
 		}
 	}
 
-	return 0, fmt.Errorf("page count with multi PDF engines: %w", err)
+	err = fmt.Errorf("page count with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return 0, err
 }
 
 type readBookmarksResult struct {
@@ -274,7 +343,13 @@ type readBookmarksResult struct {
 
 // ReadBookmarks reads bookmarks from a PDF file using the first available
 // engine that supports bookmarks reading.
-func (multi *multiPdfEngines) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.ReadBookmarks", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -293,6 +368,7 @@ func (multi *multiPdfEngines) ReadBookmarks(ctx context.Context, logger *zap.Log
 				err = multierr.Append(err, result.err)
 				mu.Unlock()
 			} else {
+				span.SetStatus(codes.Ok, "")
 				return result.bookmarks, nil
 			}
 		case <-ctx.Done():
@@ -300,12 +376,20 @@ func (multi *multiPdfEngines) ReadBookmarks(ctx context.Context, logger *zap.Log
 		}
 	}
 
-	return nil, fmt.Errorf("read PDF bookmarks with multi PDF engines: %w", err)
+	err = fmt.Errorf("read PDF bookmarks with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return nil, err
 }
 
 // WriteBookmarks adds a document outline (bookmarks) to a PDF file using the
 // first available engine that supports bookmarks writing.
-func (multi *multiPdfEngines) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (multi *multiPdfEngines) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.WriteBookmarks", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -318,6 +402,7 @@ func (multi *multiPdfEngines) WriteBookmarks(ctx context.Context, logger *zap.Lo
 		case writeBookmarksErr := <-errChan:
 			errored := multierr.AppendInto(&err, writeBookmarksErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -325,12 +410,20 @@ func (multi *multiPdfEngines) WriteBookmarks(ctx context.Context, logger *zap.Lo
 		}
 	}
 
-	return fmt.Errorf("write PDF bookmarks with multi PDF engines: %w", err)
+	err = fmt.Errorf("write PDF bookmarks with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Encrypt adds password protection to a PDF file using the first available
 // engine that supports password protection.
-func (multi *multiPdfEngines) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (multi *multiPdfEngines) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -343,6 +436,7 @@ func (multi *multiPdfEngines) Encrypt(ctx context.Context, logger *zap.Logger, i
 		case protectErr := <-errChan:
 			errored := multierr.AppendInto(&err, protectErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -350,12 +444,22 @@ func (multi *multiPdfEngines) Encrypt(ctx context.Context, logger *zap.Logger, i
 		}
 	}
 
-	return fmt.Errorf("encrypt PDF using multi PDF engines: %w", err)
+	err = fmt.Errorf("encrypt PDF using multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // EmbedFiles embeds files into a PDF using the first available
 // engine that supports file embedding.
-func (multi *multiPdfEngines) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.EmbedFiles", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -368,6 +472,7 @@ func (multi *multiPdfEngines) EmbedFiles(ctx context.Context, logger *zap.Logger
 		case embedErr := <-errChan:
 			errored := multierr.AppendInto(&err, embedErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -375,12 +480,22 @@ func (multi *multiPdfEngines) EmbedFiles(ctx context.Context, logger *zap.Logger
 		}
 	}
 
-	return fmt.Errorf("embed files into PDF using multi PDF engines: %w", err)
+	err = fmt.Errorf("embed files into PDF using multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Watermark applies a watermark (behind page content) to a PDF file using the
 // first available engine that supports watermarking.
-func (multi *multiPdfEngines) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Watermark", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -393,6 +508,7 @@ func (multi *multiPdfEngines) Watermark(ctx context.Context, logger *zap.Logger,
 		case watermarkErr := <-errChan:
 			errored := multierr.AppendInto(&err, watermarkErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -400,12 +516,22 @@ func (multi *multiPdfEngines) Watermark(ctx context.Context, logger *zap.Logger,
 		}
 	}
 
-	return fmt.Errorf("watermark PDF with multi PDF engines: %w", err)
+	err = fmt.Errorf("watermark PDF with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Stamp applies a stamp (on top of page content) to a PDF file using the
 // first available engine that supports stamping.
-func (multi *multiPdfEngines) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+//
+//nolint:dupl
+func (multi *multiPdfEngines) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Stamp", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -418,6 +544,7 @@ func (multi *multiPdfEngines) Stamp(ctx context.Context, logger *zap.Logger, inp
 		case stampErr := <-errChan:
 			errored := multierr.AppendInto(&err, stampErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -425,12 +552,20 @@ func (multi *multiPdfEngines) Stamp(ctx context.Context, logger *zap.Logger, inp
 		}
 	}
 
-	return fmt.Errorf("stamp PDF with multi PDF engines: %w", err)
+	err = fmt.Errorf("stamp PDF with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Rotate rotates pages of a PDF file using the first available engine that
 // supports rotation.
-func (multi *multiPdfEngines) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (multi *multiPdfEngines) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, "pdfengines.Rotate", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -443,6 +578,7 @@ func (multi *multiPdfEngines) Rotate(ctx context.Context, logger *zap.Logger, in
 		case rotateErr := <-errChan:
 			errored := multierr.AppendInto(&err, rotateErr)
 			if !errored {
+				span.SetStatus(codes.Ok, "")
 				return nil
 			}
 		case <-ctx.Done():
@@ -450,7 +586,11 @@ func (multi *multiPdfEngines) Rotate(ctx context.Context, logger *zap.Logger, in
 		}
 	}
 
-	return fmt.Errorf("rotate PDF with multi PDF engines: %w", err)
+	err = fmt.Errorf("rotate PDF with multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Interface guards.

pkg/modules/pdfengines/pdfengines.go

@@ -115,12 +115,12 @@ func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 	}
 
 	// Example in the case of deprecated module name.
-	//for i, name := range defaultNames {
-	//	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
-	//		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
-	//		mod.defaultNames[i] = "libreoffice-pdfengine"
-	//	}
-	//}
+	// for i, name := range defaultNames {
+	// 	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
+	// 		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
+	// 		mod.defaultNames[i] = "libreoffice-pdfengine"
+	// 	}
+	// }
 
 	mod.mergeNames = defaultNames
 	if len(mergeNames) > 0 {
@@ -253,19 +253,19 @@ func (mod *PdfEngines) Validate() error {
 // modules.
 func (mod *PdfEngines) SystemMessages() []string {
 	return []string{
-		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames[:], " ")),
-		fmt.Sprintf("split engines - %s", strings.Join(mod.splitNames[:], " ")),
-		fmt.Sprintf("flatten engines - %s", strings.Join(mod.flattenNames[:], " ")),
-		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames[:], " ")),
-		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames[:], " ")),
-		fmt.Sprintf("write metadata engines - %s", strings.Join(mod.writeMetadataNames[:], " ")),
-		fmt.Sprintf("encrypt engines - %s", strings.Join(mod.encryptNames[:], " ")),
-		fmt.Sprintf("embed engines - %s", strings.Join(mod.embedNames[:], " ")),
-		fmt.Sprintf("read bookmarks engines - %s", strings.Join(mod.readBookmarksNames[:], " ")),
-		fmt.Sprintf("write bookmarks engines - %s", strings.Join(mod.writeBookmarksNames[:], " ")),
-		fmt.Sprintf("watermark engines - %s", strings.Join(mod.watermarkNames[:], " ")),
-		fmt.Sprintf("stamp engines - %s", strings.Join(mod.stampNames[:], " ")),
-		fmt.Sprintf("rotate engines - %s", strings.Join(mod.rotateNames[:], " ")),
+		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames, " ")),
+		fmt.Sprintf("split engines - %s", strings.Join(mod.splitNames, " ")),
+		fmt.Sprintf("flatten engines - %s", strings.Join(mod.flattenNames, " ")),
+		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames, " ")),
+		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames, " ")),
+		fmt.Sprintf("write metadata engines - %s", strings.Join(mod.writeMetadataNames, " ")),
+		fmt.Sprintf("encrypt engines - %s", strings.Join(mod.encryptNames, " ")),
+		fmt.Sprintf("embed engines - %s", strings.Join(mod.embedNames, " ")),
+		fmt.Sprintf("read bookmarks engines - %s", strings.Join(mod.readBookmarksNames, " ")),
+		fmt.Sprintf("write bookmarks engines - %s", strings.Join(mod.writeBookmarksNames, " ")),
+		fmt.Sprintf("watermark engines - %s", strings.Join(mod.watermarkNames, " ")),
+		fmt.Sprintf("stamp engines - %s", strings.Join(mod.stampNames, " ")),
+		fmt.Sprintf("rotate engines - %s", strings.Join(mod.rotateNames, " ")),
 	}
 }
 

pkg/modules/pdftk/pdftk.go

@@ -5,13 +5,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"syscall"
 
-	"go.uber.org/zap"
-
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
@@ -79,7 +78,7 @@ func (engine *PdfTk) Debug() map[string]any {
 }
 
 // Split splits a given PDF file.
-func (engine *PdfTk) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (engine *PdfTk) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
 	var args []string
 	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
 
@@ -107,7 +106,7 @@ func (engine *PdfTk) Split(ctx context.Context, logger *zap.Logger, mode gotenbe
 }
 
 // Merge combines multiple PDFs into a single PDF.
-func (engine *PdfTk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (engine *PdfTk) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
 	args := make([]string, 0, 3+len(inputPaths))
 	args = append(args, inputPaths...)
 	args = append(args, "cat", "output", outputPath)
@@ -126,42 +125,42 @@ func (engine *PdfTk) Merge(ctx context.Context, logger *zap.Logger, inputPaths [
 }
 
 // Flatten is not available in this implementation.
-func (engine *PdfTk) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (engine *PdfTk) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
 	return fmt.Errorf("flatten PDF with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Convert is not available in this implementation.
-func (engine *PdfTk) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (engine *PdfTk) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
 	return nil, fmt.Errorf("read PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
 	return fmt.Errorf("write PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // PageCount is not available in this implementation.
-func (engine *PdfTk) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (engine *PdfTk) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
 	return 0, fmt.Errorf("page count with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteBookmarks is not available in this implementation.
-func (engine *PdfTk) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (engine *PdfTk) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
 	return fmt.Errorf("write PDF bookmarks with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadBookmarks is not available in this implementation.
-func (engine *PdfTk) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+func (engine *PdfTk) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
 	return nil, fmt.Errorf("read PDF bookmarks with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Encrypt adds password protection to a PDF file using PDFtk.
-func (engine *PdfTk) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (engine *PdfTk) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
 	if userPassword == "" {
 		return errors.New("user password cannot be empty")
 	}
@@ -199,13 +198,13 @@ func (engine *PdfTk) Encrypt(ctx context.Context, logger *zap.Logger, inputPath,
 }
 
 // EmbedFiles is not available in this implementation.
-func (engine *PdfTk) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+func (engine *PdfTk) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
 	return fmt.Errorf("embed files with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Watermark applies a watermark (behind page content) to a PDF file using PDFtk.
 // Only PDF source is supported.
-func (engine *PdfTk) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *PdfTk) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	if stamp.Source != gotenberg.StampSourcePDF {
 		return fmt.Errorf("watermark PDF with PDFtk: %w", gotenberg.ErrPdfStampSourceNotSupported)
 	}
@@ -234,7 +233,7 @@ func (engine *PdfTk) Watermark(ctx context.Context, logger *zap.Logger, inputPat
 
 // Stamp applies a stamp (on top of page content) to a PDF file using PDFtk.
 // Only PDF source is supported.
-func (engine *PdfTk) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *PdfTk) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	if stamp.Source != gotenberg.StampSourcePDF {
 		return fmt.Errorf("stamp PDF with PDFtk: %w", gotenberg.ErrPdfStampSourceNotSupported)
 	}
@@ -264,7 +263,7 @@ func (engine *PdfTk) Stamp(ctx context.Context, logger *zap.Logger, inputPath st
 // Rotate rotates all pages of a PDF file by the given angle using PDFtk.
 // Page-specific rotation is not supported; if pages is non-empty,
 // ErrPdfEngineMethodNotSupported is returned.
-func (engine *PdfTk) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (engine *PdfTk) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
 	if pages != "" {
 		return fmt.Errorf("rotate PDF with PDFtk (page-specific rotation): %w", gotenberg.ErrPdfEngineMethodNotSupported)
 	}

pkg/modules/prometheus/prometheus.go

@@ -177,9 +177,9 @@ func (mod *Prometheus) Routes() ([]api.Route, error) {
 
 	return []api.Route{
 		{
-			Method:         http.MethodGet,
-			Path:           mod.metricsPath,
-			DisableLogging: mod.disableRouteLogging,
+			Method:           http.MethodGet,
+			Path:             mod.metricsPath,
+			DisableTelemetry: mod.disableRouteLogging,
 			Handler: echo.WrapHandler(
 				promhttp.HandlerFor(mod.registry, promhttp.HandlerOpts{}),
 			),

pkg/modules/qpdf/qpdf.go

@@ -5,13 +5,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"syscall"
 
-	"go.uber.org/zap"
-
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
@@ -82,7 +81,7 @@ func (engine *QPdf) Debug() map[string]any {
 }
 
 // Split splits a given PDF file.
-func (engine *QPdf) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+func (engine *QPdf) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
 	var args []string
 	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
 
@@ -113,7 +112,7 @@ func (engine *QPdf) Split(ctx context.Context, logger *zap.Logger, mode gotenber
 }
 
 // Merge combines multiple PDFs into a single PDF.
-func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+func (engine *QPdf) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
 	args := make([]string, 0, 4+len(engine.globalArgs)+len(inputPaths))
 	args = append(args, "--empty")
 	args = append(args, engine.globalArgs...)
@@ -136,7 +135,7 @@ func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 
 // Flatten merges annotation appearances with page content, deleting the
 // original annotations.
-func (engine *QPdf) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
+func (engine *QPdf) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
 	args := make([]string, 0, 4+len(engine.globalArgs))
 	args = append(args, inputPath)
 	args = append(args, "--generate-appearances")
@@ -158,37 +157,37 @@ func (engine *QPdf) Flatten(ctx context.Context, logger *zap.Logger, inputPath s
 }
 
 // Convert is not available in this implementation.
-func (engine *QPdf) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+func (engine *QPdf) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with QPDF: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *QPdf) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
+func (engine *QPdf) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
 	return nil, fmt.Errorf("read PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *QPdf) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
+func (engine *QPdf) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
 	return fmt.Errorf("write PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // PageCount is not available in this implementation.
-func (engine *QPdf) PageCount(ctx context.Context, logger *zap.Logger, inputPath string) (int, error) {
+func (engine *QPdf) PageCount(ctx context.Context, logger *slog.Logger, inputPath string) (int, error) {
 	return 0, fmt.Errorf("page count with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // WriteBookmarks is not available in this implementation.
-func (engine *QPdf) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
+func (engine *QPdf) WriteBookmarks(ctx context.Context, logger *slog.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
 	return fmt.Errorf("write PDF bookmarks with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // ReadBookmarks is not available in this implementation.
-func (engine *QPdf) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
+func (engine *QPdf) ReadBookmarks(ctx context.Context, logger *slog.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
 	return nil, fmt.Errorf("read PDF bookmarks with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Encrypt adds password protection to a PDF file using QPDF.
-func (engine *QPdf) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
+func (engine *QPdf) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
 	if userPassword == "" {
 		return errors.New("user password cannot be empty")
 	}
@@ -217,22 +216,22 @@ func (engine *QPdf) Encrypt(ctx context.Context, logger *zap.Logger, inputPath,
 }
 
 // EmbedFiles is not available in this implementation.
-func (engine *QPdf) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
+func (engine *QPdf) EmbedFiles(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
 	return fmt.Errorf("embed files with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Watermark is not available in this implementation.
-func (engine *QPdf) Watermark(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *QPdf) Watermark(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("watermark PDF with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Stamp is not available in this implementation.
-func (engine *QPdf) Stamp(ctx context.Context, logger *zap.Logger, inputPath string, stamp gotenberg.Stamp) error {
+func (engine *QPdf) Stamp(ctx context.Context, logger *slog.Logger, inputPath string, stamp gotenberg.Stamp) error {
 	return fmt.Errorf("stamp PDF with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 
 // Rotate is not available in this implementation.
-func (engine *QPdf) Rotate(ctx context.Context, logger *zap.Logger, inputPath string, angle int, pages string) error {
+func (engine *QPdf) Rotate(ctx context.Context, logger *slog.Logger, inputPath string, angle int, pages string) error {
 	return fmt.Errorf("rotate PDF with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }
 

pkg/modules/webhook/client.go

@@ -1,15 +1,22 @@
 package webhook
 
 import (
+	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"strconv"
 	"time"
 
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/trace"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
 // client gathers all the data required to send a request to a webhook.
@@ -22,11 +29,11 @@ type client struct {
 	startTime        time.Time
 
 	client *retryablehttp.Client
-	logger *zap.Logger
+	logger *slog.Logger
 }
 
 // send call the webhook either to send the success response or the error response.
-func (c client) send(body io.Reader, headers map[string]string, errored bool) error {
+func (c client) send(ctx context.Context, body io.Reader, headers map[string]string, errored bool) error {
 	url := c.url
 	if errored {
 		url = c.errorUrl
@@ -37,11 +44,25 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 		method = c.errorMethod
 	}
 
+	spanName := fmt.Sprintf("%s Webhook", method)
+	if errored {
+		spanName = fmt.Sprintf("%s Webhook Error", method)
+	}
+
+	tracer := gotenberg.Tracer()
+	ctx, span := tracer.Start(ctx, spanName, trace.WithSpanKind(trace.SpanKindClient))
+	defer span.End()
+
 	req, err := retryablehttp.NewRequest(method, url, body)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		return fmt.Errorf("create '%s' request to '%s': %w", method, url, err)
 	}
 
+	// Inject trace context into outbound request headers.
+	otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))
+
 	req.Header.Set("User-Agent", "Gotenberg")
 
 	// Extra HTTP headers are the custom headers from the user.
@@ -63,6 +84,8 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 
 		bodySize, err := strconv.ParseInt(contentLength, 10, 64)
 		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
 			return fmt.Errorf("parse content length entry: %w", err)
 		}
 
@@ -75,17 +98,22 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 
 	resp, err := c.client.Do(req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		return fmt.Errorf("send '%s' request to '%s': %w", method, url, err)
 	}
 
 	if resp.StatusCode >= http.StatusBadRequest {
-		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, url, resp.Status)
+		err := fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, url, resp.Status)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	defer func() {
 		err := resp.Body.Close()
 		if err != nil {
-			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", url, err))
+			c.logger.ErrorContext(ctx, fmt.Sprintf("close response body from '%s': %s", url, err))
 		}
 	}()
 
@@ -93,20 +121,22 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 	finishTime := time.Now()
 
 	// Now let's log!
-	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(c.startTime)))
-	fields[3] = zap.String("latency_human", finishTime.Sub(c.startTime).String())
-	fields[4] = zap.Int64("bytes_out", req.ContentLength)
+	attrs := []any{
+		slog.String("webhook_url", url),
+		slog.String("method", method),
+		slog.Int64("latency", int64(finishTime.Sub(c.startTime))),
+		slog.String("latency_human", finishTime.Sub(c.startTime).String()),
+		slog.Int64("bytes_out", req.ContentLength),
+	}
 
 	if errored {
-		c.logger.Warn("request to webhook with error details handled", fields...)
-
+		c.logger.WarnContext(ctx, "request to webhook with error details handled", attrs...)
+		span.SetStatus(codes.Ok, "")
 		return nil
 	}
 
-	c.logger.Info("request to webhook handled", fields...)
+	c.logger.InfoContext(ctx, "request to webhook handled", attrs...)
+	span.SetStatus(codes.Ok, "")
 
 	return nil
 }

pkg/modules/webhook/middleware.go

@@ -21,13 +21,13 @@ import (
 )
 
 type sendOutputFileParams struct {
-	ctx              *api.Context
-	outputPath       string
-	extraHttpHeaders map[string]string
-	traceHeader      string
-	trace            string
-	client           *client
-	handleError      func(error)
+	ctx                 *api.Context
+	outputPath          string
+	extraHttpHeaders    map[string]string
+	correlationIdHeader string
+	correlationId       string
+	client              *client
+	handleError         func(error)
 }
 
 func webhookMiddleware(w *Webhook) api.Middleware {
@@ -72,16 +72,16 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 					}
 
 					headers := map[string]string{
-						echo.HeaderContentType:   http.DetectContentType(fileHeader),
-						echo.HeaderContentLength: strconv.FormatInt(fileStat.Size(), 10),
-						params.traceHeader:       params.trace,
+						echo.HeaderContentType:     http.DetectContentType(fileHeader),
+						echo.HeaderContentLength:   strconv.FormatInt(fileStat.Size(), 10),
+						params.correlationIdHeader: params.correlationId,
 					}
 					_, ok := params.extraHttpHeaders[echo.HeaderContentDisposition]
 					if !ok {
 						headers[echo.HeaderContentDisposition] = fmt.Sprintf("attachment; filename=%q", params.ctx.OutputFilename(params.outputPath))
 					}
 
-					err = params.client.send(bufio.NewReader(outputFile), headers, false)
+					err = params.client.send(params.ctx, bufio.NewReader(outputFile), headers, false)
 					if err != nil {
 						params.ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
 						params.handleError(err)
@@ -179,8 +179,8 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 					// Retrieve values from echo.Context before it gets recycled.
 					// See https://github.com/gotenberg/gotenberg/issues/1000.
 					startTime := c.Get("startTime").(time.Time)
-					traceHeader := c.Get("traceHeader").(string)
-					trace := c.Get("trace").(string)
+					correlationIdHeader := c.Get("correlationIdHeader").(string)
+					correlationId := c.Get("correlationId").(string)
 
 					client := &client{
 						url:              webhookUrl,
@@ -226,10 +226,10 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 
 						headers := map[string]string{
 							echo.HeaderContentType: echo.MIMEApplicationJSON,
-							traceHeader:            trace,
+							correlationIdHeader:    correlationId,
 						}
 
-						err = client.send(bytes.NewReader(b), headers, true)
+						err = client.send(ctx, bytes.NewReader(b), headers, true)
 						if err != nil {
 							ctx.Log().Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
 						}
@@ -262,13 +262,13 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 						// No error, let's send the output file to the webhook URL.
 						sendOutputFile(sendOutputFileParams{
-							ctx:              ctx,
-							outputPath:       outputPath,
-							extraHttpHeaders: extraHttpHeaders,
-							traceHeader:      traceHeader,
-							trace:            trace,
-							client:           client,
-							handleError:      handleError,
+							ctx:                 ctx,
+							outputPath:          outputPath,
+							extraHttpHeaders:    extraHttpHeaders,
+							correlationIdHeader: correlationIdHeader,
+							correlationId:       correlationId,
+							client:              client,
+							handleError:         handleError,
 						})
 						return c.NoContent(http.StatusNoContent)
 					}
@@ -332,13 +332,13 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 
 						sendOutputFile(sendOutputFileParams{
-							ctx:              ctx,
-							outputPath:       outputPath,
-							extraHttpHeaders: extraHttpHeaders,
-							traceHeader:      traceHeader,
-							trace:            trace,
-							client:           client,
-							handleError:      handleError,
+							ctx:                 ctx,
+							outputPath:          outputPath,
+							extraHttpHeaders:    extraHttpHeaders,
+							correlationIdHeader: correlationIdHeader,
+							correlationId:       correlationId,
+							client:              client,
+							handleError:         handleError,
 						})
 					}()