refactor(pdfengines): embeds => attachments

pkg/modules/api/api.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net"
 	"net/http"
+	"os"
 	"sort"
 	"strings"
 	"time"
@@ -15,7 +17,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"
 
@@ -27,22 +28,25 @@ func init() {
 }
 
 // Api is a module that provides an HTTP server. Other modules may add routes,
-// middlewares or health checks.
+// 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
+	basicAuthUsername                string
+	basicAuthPassword                string
+	correlationIdHeader              string
+	downloadFromCfg                  downloadFromConfig
+	disableHealthCheckRouteTelemetry bool
+	disableRootRouteTelemetry        bool
+	disableVersionRouteTelemetry     bool
+	disableDebugRouteTelemetry       bool
+	enableDebugRoute                 bool
 
 	routes              []Route
 	externalMiddlewares []Middleware
@@ -50,7 +54,7 @@ type Api struct {
 	readyFn             []func() error
 	asyncCounters       []AsynchronousCounter
 	fs                  *gotenberg.FileSystem
-	logger              *zap.Logger
+	logger              *slog.Logger
 	srv                 *echo.Echo
 }
 
@@ -80,9 +84,9 @@ type Route struct {
 	// Optional.
 	IsMultipart bool
 
-	// DisableLogging disables the logging for this route.
+	// DisableTelemetry disables the telemetry and logging for this route.
 	// Optional.
-	DisableLogging bool
+	DisableTelemetry bool
 
 	// Handler is the function that handles the request.
 	// Required.
@@ -118,29 +122,6 @@ const (
 
 // Middleware is a middleware that can be added to the [Api]'s middlewares
 // chain.
-//
-//	middleware := Middleware{
-//	  Handler: func() echo.MiddlewareFunc {
-//	    return func(next echo.HandlerFunc) echo.HandlerFunc {
-//	      return func(c echo.Context) error {
-//	        rootPath := c.Get("rootPath").(string)
-//	        healthURI := fmt.Sprintf("%shealth", rootPath)
-//
-//	        // Skip the middleware if health check URI.
-//	        if c.Request().RequestURI == healthURI {
-//	          // Call the next middleware in the chain.
-//	          return next(c)
-//	        }
-//
-//	        // Your middleware process.
-//	        // ...
-//
-//	        // Call the next middleware in the chain.
-//	        return next(c)
-//	      }
-//	    }
-//	  }(),
-//	}
 type Middleware struct {
 	// Stack tells in which stack the middleware should be located.
 	// Default to [DefaultStack].
@@ -190,14 +171,18 @@ 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.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.String("api-correlation-id-header", "X-Correlation-ID", "Set the header name to use to set the correlation id in the logs")
 			fs.String("api-download-from-allow-list", "", "Set the allowed URLs for the download from feature using a regular expression")
 			fs.String("api-download-from-deny-list", "", "Set the denied URLs for the download from feature using a regular expression")
 			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 the health check route telemetry")
+			fs.Bool("api-disable-root-route-telemetry", false, "Disable the root route telemetry")
+			fs.Bool("api-disable-version-route-telemetry", false, "Disable the version route telemetry")
+			fs.Bool("api-disable-debug-route-telemetry", false, "Disable the debug route telemetry")
 			fs.Bool("api-enable-debug-route", false, "Enable the debug route")
+
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(Api) },
@@ -215,14 +200,17 @@ 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.MustString("api-correlation-id-header")
 	a.downloadFromCfg = downloadFromConfig{
 		allowList: flags.MustRegexp("api-download-from-allow-list"),
 		denyList:  flags.MustRegexp("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.MustBool("api-disable-health-check-route-telemetry")
+	a.disableRootRouteTelemetry = flags.MustBool("api-disable-root-route-telemetry")
+	a.disableVersionRouteTelemetry = flags.MustBool("api-disable-version-route-telemetry")
+	a.disableDebugRouteTelemetry = flags.MustBool("api-disable-debug-route-telemetry")
 	a.enableDebugRoute = flags.MustBool("api-enable-debug-route")
 
 	// Port from env?
@@ -328,17 +316,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,12 +356,6 @@ func (a *Api) Validate() error {
 		)
 	}
 
-	if len(strings.TrimSpace(a.traceHeader)) == 0 {
-		err = multierr.Append(err,
-			errors.New("trace header must not be empty"),
-		)
-	}
-
 	if err != nil {
 		return err
 	}
@@ -442,28 +414,48 @@ 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 system routes.
+	// Note: root path will be used as prefix in the underlying middlewares.
+	if a.disableHealthCheckRouteTelemetry {
+		disableTelemetryForPaths = append(disableTelemetryForPaths, "health")
 	}
 
+	if a.disableRootRouteTelemetry {
+		disableTelemetryForPaths = append(disableTelemetryForPaths, "")
+	}
+
+	if a.disableVersionRouteTelemetry {
+		disableTelemetryForPaths = append(disableTelemetryForPaths, "version")
+	}
+
+	if a.disableDebugRouteTelemetry {
+		disableTelemetryForPaths = append(disableTelemetryForPaths, "debug")
+	}
+
+	// Always disable telemetry for favicon.
+	disableTelemetryForPaths = append(disableTelemetryForPaths,
+		"favicon.ico",
+	)
+
 	// Add the API middlewares.
+	hostname, err := os.Hostname()
+	if err != nil {
+		return fmt.Errorf("get hostname: %w", err)
+	}
+
 	a.srv.Pre(
 		latencyMiddleware(),
 		rootPathMiddleware(a.rootPath),
-		traceMiddleware(a.traceHeader),
 		outputFilenameMiddleware(),
-		loggerMiddleware(a.logger, disableLoggingForPaths),
+		telemetryMiddleware(a.logger, hostname, a.correlationIdHeader, disableTelemetryForPaths),
 	)
 
 	// Add the modules' middlewares in their respective stacks.
@@ -583,7 +575,7 @@ func (a *Api) Start() error {
 		eg.Go(f)
 	}
 
-	err := eg.Wait()
+	err = eg.Wait()
 	if err != nil {
 		return fmt.Errorf("waiting for modules readiness: %w", err)
 	}
@@ -600,7 +592,8 @@ 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())
+			os.Exit(1)
 		}
 	}()
 
@@ -627,12 +620,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,11 +20,14 @@ 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"
+	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/unicode/norm"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	semconvutil "github.com/gotenberg/gotenberg/v8/pkg/gotenberg/semconv"
 )
 
 var (
@@ -36,7 +40,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 +49,7 @@ type Context struct {
 	outputPaths  []string
 	cancelled    bool
 
-	logger     *zap.Logger
+	logger     *slog.Logger
 	echoCtx    echo.Context
 	mkdirAll   gotenberg.MkdirAll
 	pathRename gotenberg.PathRename
@@ -81,12 +85,12 @@ type downloadFrom struct {
 	// ExtraHttpHeaders are the HTTP headers to send alongside.
 	ExtraHttpHeaders map[string]string `json:"extraHttpHeaders"`
 
-	// Download as embed file
-	Embedded bool `json:"embedded"`
+	// Download as an attachment file.
+	Attachment bool `json:"attachment"`
 }
 
 // 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
@@ -131,12 +135,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(ctx, 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(ctx, fmt.Sprintf("'%s' context's working directory removed", ctx.dirPath))
 			ctx.cancelled = true
 		}
 	}()
@@ -224,9 +228,9 @@ 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)
+				req, err := retryablehttp.NewRequestWithContext(ctx, http.MethodGet, dl.Url, nil)
 				if err != nil {
 					return fmt.Errorf("create request to '%s': %w", dl.Url, err)
 				}
@@ -235,7 +239,20 @@ 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)
+				req.Header.Set(echoCtx.Get("correlationIdHeader").(string), echoCtx.Get("correlationId").(string))
+
+				// OpenTelemetry.
+				meter := gotenberg.Meter()
+				semconvClient := semconvutil.NewHTTPClient(meter)
+
+				tracer := gotenberg.Tracer()
+				traceCtx, span := tracer.Start(ctx, fmt.Sprintf("%s Download From", req.Method),
+					trace.WithSpanKind(trace.SpanKindClient),
+					trace.WithAttributes(semconvClient.RequestTraceAttrs(req.Request)...),
+				)
+				defer span.End()
+
+				otel.GetTextMapPropagator().Inject(traceCtx, propagation.HeaderCarrier(req.Header))
 
 				client := &retryablehttp.Client{
 					HTTPClient: &http.Client{
@@ -244,22 +261,27 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 					RetryMax:     downloadFromCfg.maxRetry,
 					RetryWaitMin: time.Duration(1) * time.Second,
 					RetryWaitMax: time.Until(deadline),
-					Logger:       gotenberg.NewLeveledLogger(logger),
+					Logger:       gotenberg.NewLeveledLogger(logger).WithContext(ctx),
 					CheckRetry:   retryablehttp.DefaultRetryPolicy,
 					Backoff:      retryablehttp.DefaultBackoff,
 				}
 
 				resp, err := client.Do(req)
 				if err != nil {
+					span.RecordError(err)
+					span.SetStatus(semconvClient.Status(0))
 					return WrapError(
 						fmt.Errorf("download file from to '%s': %w", dl.Url, err),
 						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': %s", dl.Url, err)),
 					)
 				}
+
+				span.SetAttributes(semconvClient.ResponseTraceAttrs(resp)...)
+				span.SetStatus(semconvClient.Status(resp.StatusCode))
 				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))
 					}
 				}()
 
@@ -301,7 +323,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 				// normalized.
 				// See: https://github.com/gotenberg/gotenberg/issues/662.
 				filename = norm.NFC.String(filepath.Base(filename))
-				path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+				path := fmt.Sprintf("%s/%s", dirPath, filename)
 
 				out, err := os.Create(path)
 				if err != nil {
@@ -310,7 +332,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))
 					}
 				}()
 
@@ -323,8 +345,8 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 				}
 
 				ctx.files[filename] = path
-				if dl.Embedded {
-					ctx.filesByField[EmbedsFormField] = append(ctx.filesByField[EmbedsFormField], path)
+				if dl.Attachment {
+					ctx.filesByField[AttachmentsFormField] = append(ctx.filesByField[AttachmentsFormField], path)
 				}
 
 				return nil
@@ -346,7 +368,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(ctx, fmt.Sprintf("close file header: %s", err))
 			}
 		}()
 
@@ -366,7 +388,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))
 			}
 		}()
 
@@ -394,10 +416,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
 }
@@ -444,7 +466,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)
@@ -470,8 +492,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
 }
 
@@ -487,7 +509,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
 	}
 
@@ -510,7 +532,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)
 
@@ -519,7 +541,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,14 +3,15 @@ package api
 import (
 	"bytes"
 	"context"
+	"log/slog"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 	"time"
 
 	"github.com/labstack/echo/v4"
-	"go.uber.org/zap"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -35,14 +36,14 @@ func TestNewContext_Cancellation(t *testing.T) {
 	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
 
-	logger := zap.NewNop()
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	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/formdata.go

@@ -17,9 +17,9 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
 
-// EmbedsFormField represents the form field name for embedding files.
+// AttachmentsFormField represents the form field name for attaching files.
 const (
-	EmbedsFormField string = "embeds"
+	AttachmentsFormField string = "attachments"
 )
 
 // FormData is a helper for validating and hydrating values from a
@@ -365,20 +365,20 @@ func (form *FormData) Paths(extensions []string, target *[]string) *FormData {
 	return form.paths(extensions, target)
 }
 
-// Embeds binds the absolute paths of form data files that should be
-// embedded in the PDF. Only files uploaded with the "embeds" field name
+// Attachments binds the absolute paths of form data files that should be
+// attached in the PDF. Only files uploaded with the "attachments" field name
 // will be included.
 //
-//	var embeds []string
+//	var attachments []string
 //
-//	ctx.FormData().Embeds(&embeds)
-func (form *FormData) Embeds(target *[]string) *FormData {
+//	ctx.FormData().Attachments(&attachments)
+func (form *FormData) Attachments(target *[]string) *FormData {
 	if form.errors != nil {
 		return form
 	}
 
-	// Get files from the "embeds" field
-	if paths, ok := form.filesByField[EmbedsFormField]; ok {
+	// Get files from the "attachments" field
+	if paths, ok := form.filesByField[AttachmentsFormField]; ok {
 		*target = append(*target, paths...)
 	}
 
@@ -408,12 +408,12 @@ func (form *FormData) MandatoryPaths(extensions []string, target *[]string) *For
 
 // paths bind the absolute paths of form data files, according to a list of
 // file extensions, to a string slice variable.
-// embeds are excluded.
+// attachments are excluded.
 func (form *FormData) paths(extensions []string, target *[]string) *FormData {
-	embeds, ok := form.filesByField[EmbedsFormField]
+	attachments, ok := form.filesByField[AttachmentsFormField]
 
 	for filename, path := range form.files {
-		if ok && slices.Contains(embeds, path) {
+		if ok && slices.Contains(attachments, path) {
 			continue
 		}
 

pkg/modules/api/formdata_test.go

@@ -1613,15 +1613,15 @@ func TestFormData_Paths(t *testing.T) {
 			expectCount: 2,
 		},
 		{
-			scenario: "files except embeds",
+			scenario: "files except attachments",
 			form: &FormData{
 				files: map[string]string{
-					"foo.pdf":     "/foo.pdf",
-					"embed_1.pdf": "/embed_1.pdf",
-					"embed_2.xml": "/embed_2.xml",
+					"foo.pdf":           "/foo.pdf",
+					"attachments_1.pdf": "/attachments_1.pdf",
+					"attachments_2.xml": "/attachments_2.xml",
 				},
 				filesByField: map[string][]string{
-					"embeds": {"/embed_1.pdf", "/embed_2.xml"},
+					"attachments": {"/attachments_1.pdf", "/attachments_2.xml"},
 				},
 			},
 			extensions: []string{".pdf"},
@@ -1759,7 +1759,7 @@ func TestFormData_mustAssign(t *testing.T) {
 	form.mustAssign("foo", "foo", &target)
 }
 
-func TestFormData_Embeds(t *testing.T) {
+func TestFormData_Attachments(t *testing.T) {
 	expected := []string{"/bar.xml", "/baz.xml"}
 
 	var actual []string
@@ -1770,13 +1770,13 @@ func TestFormData_Embeds(t *testing.T) {
 			"baz.xml": "/baz.xml",
 		},
 		filesByField: map[string][]string{
-			"embeds": {"/bar.xml", "/baz.xml"},
+			"attachments": {"/bar.xml", "/baz.xml"},
 		},
 	}
-	form.Embeds(&actual)
+	form.Attachments(&actual)
 
 	if len(actual) != len(expected) {
-		t.Errorf("expected %d embeds but got %d", len(expected), len(actual))
+		t.Errorf("expected %d attachments but got %d", len(expected), len(actual))
 	}
 
 	if !reflect.DeepEqual(actual, expected) {

pkg/modules/api/middlewares.go

@@ -5,6 +5,8 @@ import (
 	"crypto/subtle"
 	"errors"
 	"fmt"
+	"io"
+	"log/slog"
 	"net/http"
 	"path/filepath"
 	"strings"
@@ -13,9 +15,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 (
@@ -79,14 +85,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()))
 		}
 	}
 }
@@ -130,32 +136,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".
 //
@@ -175,59 +155,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 == "" {
@@ -235,21 +184,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.NewJSONHandler(io.Discard, nil)))
+
+				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
 		}
 	}
@@ -276,13 +331,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()
 
@@ -336,7 +389,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.
@@ -353,7 +406,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))
 					}
 				}()
 
@@ -365,7 +418,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.New(slog.NewJSONHandler(os.Stdout, nil)))
+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,18 @@ import (
 	"github.com/chromedp/chromedp"
 	"github.com/dlclark/regexp2"
 	"github.com/shirou/gopsutil/v4/process"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	semconv "go.opentelemetry.io/otel/semconv/v1.39.0"
+	"go.opentelemetry.io/otel/trace"
 
 	"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,12 +76,15 @@ 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")
 	}
 
-	debug := &debugLogger{logger: logger}
+	debug := &debugLogger{
+		ctx:    b.initialCtx,
+		logger: logger,
+	}
 	b.userProfileDirPath = b.fs.NewDirPath()
 
 	// See https://github.com/gotenberg/gotenberg/issues/1293.
@@ -164,7 +171,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 +188,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 +206,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(killCtx, fmt.Sprintf("kill process: %v", err))
 					} else {
-						logger.Debug(fmt.Sprintf("Chromium process %d killed", p.Pid))
+						logger.DebugContext(killCtx, fmt.Sprintf("Chromium process %d killed", p.Pid))
 					}
 				}()
 			}
@@ -215,15 +222,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 +246,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 +273,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(ctx, 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 +306,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 +333,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")
 	}
@@ -412,7 +419,26 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		resourceLoadingFailedMu: &resourceLoadingFailedMu,
 	})
 
-	err = chromedp.Run(taskCtx, tasks...)
+	clientCtx, clientSpan := gotenberg.Tracer().Start(taskCtx, "cdp.execute",
+		trace.WithSpanKind(trace.SpanKindClient),
+		trace.WithAttributes(
+			semconv.ServerAddress("127.0.0.1"),
+			semconv.ServicePeerName("chromium"),
+			semconv.RPCSystemNameKey.String("cdp"),
+			// Legacy attribute for older APMs (Datadog, Jaeger) to draw the
+			// dependency graph.
+			attribute.String("peer.service", "chromium"),
+		),
+	)
+
+	err = chromedp.Run(clientCtx, tasks...)
+	if err != nil {
+		clientSpan.RecordError(err)
+		clientSpan.SetStatus(codes.Error, err.Error())
+	}
+
+	clientSpan.End()
+
 	if err != nil {
 		errMessage := err.Error()
 

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/codes"
+	"go.opentelemetry.io/otel/metric"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
@@ -91,7 +93,7 @@ type Chromium struct {
 	maxConcurrency int64
 	args           browserArguments
 
-	logger     *zap.Logger
+	logger     *slog.Logger
 	browser    browser
 	supervisor gotenberg.ProcessSupervisor
 	engine     gotenberg.PdfEngine
@@ -268,7 +270,7 @@ type PdfOptions struct {
 	PreferCssPageSize bool
 
 	// GenerateDocumentOutline defines whether the document outline should be
-	// embedded into the PDF.
+	// attached into the PDF.
 	GenerateDocumentOutline bool
 
 	// GenerateTaggedPdf defines whether to generate tagged (accessible)
@@ -389,8 +391,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]
@@ -428,13 +430,6 @@ func (mod *Chromium) Descriptor() gotenberg.ModuleDescriptor {
 			fs.Bool("chromium-disable-javascript", false, "Disable JavaScript")
 			fs.Bool("chromium-disable-routes", false, "Disable the routes")
 
-			// Deprecated flags.
-			fs.Bool("chromium-incognito", false, "Start Chromium with incognito mode")
-			err := fs.MarkDeprecated("chromium-incognito", "this flag is ignored as it provides no benefits")
-			if err != nil {
-				panic(err)
-			}
-
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(Chromium) },
@@ -477,15 +472,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)
@@ -502,6 +489,36 @@ func (mod *Chromium) Provision(ctx *gotenberg.Context) error {
 	}
 	mod.engine = engine
 
+	// OpenTelemetry.
+	meter := gotenberg.Meter()
+	_, 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 {
+			val := mod.supervisor.RestartsCount()
+			o.Observe(val)
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create process restarts observable counter: %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 {
+			val := mod.supervisor.ReqQueueSize()
+			o.Observe(val)
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create requests queue size observable gauge: %w", err)
+	}
+
 	return nil
 }
 
@@ -552,7 +569,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()
 
@@ -581,26 +598,6 @@ func (mod *Chromium) Debug() map[string]any {
 	return debug
 }
 
-// Metrics returns the metrics.
-func (mod *Chromium) Metrics() ([]gotenberg.Metric, error) {
-	return []gotenberg.Metric{
-		{
-			Name:        "chromium_requests_queue_size",
-			Description: "Current number of Chromium conversion requests waiting to be treated.",
-			Read: func() float64 {
-				return float64(mod.supervisor.ReqQueueSize())
-			},
-		},
-		{
-			Name:        "chromium_restarts_count",
-			Description: "Current number of Chromium restarts.",
-			Read: func() float64 {
-				return float64(mod.supervisor.RestartsCount())
-			},
-		},
-	}, nil
-}
-
 // Checks adds a health check that verifies if Chromium is healthy.
 func (mod *Chromium) Checks() ([]health.CheckerOption, error) {
 	return []health.CheckerOption{
@@ -668,32 +665,49 @@ 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 {
+func (mod *Chromium) 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 mod.supervisor.Run(ctx, logger, func() error {
+	ctx, span := gotenberg.Tracer().Start(ctx, "Chromium.Pdf")
+	defer span.End()
+
+	err := mod.supervisor.Run(ctx, logger, func() error {
 		return mod.browser.pdf(ctx, logger, url, outputPath, options)
 	})
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
-func (mod *Chromium) Screenshot(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+func (mod *Chromium) 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 mod.supervisor.Run(ctx, logger, func() error {
+	ctx, span := gotenberg.Tracer().Start(ctx, "Chromium.Screenshot")
+	defer span.End()
+
+	err := mod.supervisor.Run(ctx, logger, func() error {
 		return mod.browser.screenshot(ctx, logger, url, outputPath, options)
 	})
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Interface guards.
 var (
-	_ gotenberg.Module          = (*Chromium)(nil)
-	_ gotenberg.Provisioner     = (*Chromium)(nil)
-	_ gotenberg.Validator       = (*Chromium)(nil)
-	_ gotenberg.App             = (*Chromium)(nil)
-	_ gotenberg.Debuggable      = (*Chromium)(nil)
-	_ gotenberg.MetricsProvider = (*Chromium)(nil)
-	_ api.HealthChecker         = (*Chromium)(nil)
-	_ api.Router                = (*Chromium)(nil)
-	_ Api                       = (*Chromium)(nil)
-	_ Provider                  = (*Chromium)(nil)
+	_ gotenberg.Module      = (*Chromium)(nil)
+	_ gotenberg.Provisioner = (*Chromium)(nil)
+	_ gotenberg.Validator   = (*Chromium)(nil)
+	_ gotenberg.App         = (*Chromium)(nil)
+	_ gotenberg.Debuggable  = (*Chromium)(nil)
+	_ api.HealthChecker     = (*Chromium)(nil)
+	_ api.Router            = (*Chromium)(nil)
+	_ Api                   = (*Chromium)(nil)
+	_ Provider              = (*Chromium)(nil)
 )

pkg/modules/chromium/debug.go

@@ -1,28 +1,29 @@
 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
+	ctx    context.Context
+	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(debug.ctx, 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(debug.ctx, 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"
@@ -32,29 +32,29 @@ 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:
 			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
 				}
 
@@ -65,7 +65,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
 				}
@@ -81,25 +81,25 @@ 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))
+							logger.ErrorContext(ctx, 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))
+							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))
+							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)
@@ -109,7 +109,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))
 						}
 					}
 
@@ -132,7 +132,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))
 				}
 			}()
 		}
@@ -157,7 +157,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)
@@ -180,7 +180,7 @@ func listenForEventResponseReceived(
 		switch ev := ev.(type) {
 		case *network.EventResponseReceived:
 			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()
@@ -192,11 +192,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
 				}
 
@@ -298,11 +298,11 @@ 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))
+			logger.DebugContext(ctx, fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
 
 			// We are looking for common errors.
 			// TODO: sufficient?
@@ -321,14 +321,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()
@@ -338,7 +338,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()
@@ -354,11 +354,11 @@ 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))
+			logger.DebugContext(ctx, fmt.Sprintf("event EventExceptionThrown fired: %+v", ev.ExceptionDetails))
 
 			consoleExceptionsMu.Lock()
 			defer consoleExceptionsMu.Unlock()
@@ -370,7 +370,7 @@ 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)
@@ -384,7 +384,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())
@@ -394,7 +394,7 @@ 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)
@@ -408,7 +408,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())
@@ -418,7 +418,7 @@ 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)
@@ -434,7 +434,7 @@ func waitForEventNetworkIdle(ctx context.Context, logger *zap.Logger) func() err
 
 		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())
@@ -444,7 +444,7 @@ func waitForEventNetworkIdle(ctx context.Context, logger *zap.Logger) func() err
 
 // 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)
@@ -458,7 +458,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

@@ -414,7 +414,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			pdfFormats := pdfengines.FormDataPdfFormats(form)
 			metadata := pdfengines.FormDataPdfMetadata(form, false)
 			userPassword, ownerPassword := pdfengines.FormDataPdfEncrypt(form)
-			embedPaths := pdfengines.FormDataPdfEmbeds(form)
+			attachmentsPaths := pdfengines.FormDataPdfAttachments(form)
 
 			var url string
 			err := form.
@@ -424,7 +424,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, embedPaths)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, attachmentsPaths)
 			if err != nil {
 				return fmt.Errorf("convert URL to PDF: %w", err)
 			}
@@ -477,7 +477,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			pdfFormats := pdfengines.FormDataPdfFormats(form)
 			metadata := pdfengines.FormDataPdfMetadata(form, false)
 			userPassword, ownerPassword := pdfengines.FormDataPdfEncrypt(form)
-			embedPaths := pdfengines.FormDataPdfEmbeds(form)
+			attachmentsPaths := pdfengines.FormDataPdfAttachments(form)
 
 			var inputPath string
 			err := form.
@@ -488,7 +488,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			}
 
 			url := fmt.Sprintf("file://%s", inputPath)
-			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, embedPaths)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, attachmentsPaths)
 			if err != nil {
 				return fmt.Errorf("convert HTML to PDF: %w", err)
 			}
@@ -542,7 +542,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			pdfFormats := pdfengines.FormDataPdfFormats(form)
 			metadata := pdfengines.FormDataPdfMetadata(form, false)
 			userPassword, ownerPassword := pdfengines.FormDataPdfEncrypt(form)
-			embedPaths := pdfengines.FormDataPdfEmbeds(form)
+			attachmentsPaths := pdfengines.FormDataPdfAttachments(form)
 
 			var (
 				inputPath     string
@@ -562,7 +562,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
 			}
 
-			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, embedPaths)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata, userPassword, ownerPassword, attachmentsPaths)
 			if err != nil {
 				return fmt.Errorf("convert markdown to PDF: %w", err)
 			}
@@ -686,7 +686,7 @@ func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string)
 	return fmt.Sprintf("file://%s", inputPath), nil
 }
 
-func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, options PdfOptions, mode gotenberg.SplitMode, pdfFormats gotenberg.PdfFormats, metadata map[string]any, userPassword, ownerPassword string, embedPaths []string) error {
+func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, options PdfOptions, mode gotenberg.SplitMode, pdfFormats gotenberg.PdfFormats, metadata map[string]any, userPassword, ownerPassword string, attachmentsPaths []string) error {
 	outputPath := ctx.GeneratePath(".pdf")
 	// See https://github.com/gotenberg/gotenberg/issues/1130.
 	filename := ctx.OutputFilename(outputPath)
@@ -758,9 +758,9 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		return fmt.Errorf("convert PDF(s): %w", err)
 	}
 
-	err = pdfengines.EmbedFilesStub(ctx, engine, embedPaths, convertOutputPaths)
+	err = pdfengines.AddAttachmentsStub(ctx, engine, attachmentsPaths, convertOutputPaths)
 	if err != nil {
-		return fmt.Errorf("embed files into PDFs: %w", err)
+		return fmt.Errorf("add attachments into PDFs: %w", err)
 	}
 
 	err = pdfengines.WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)

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,14 +303,14 @@ 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 {
+//func extraHttpHeadersActionFunc(logger *slog.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
 //	return func(ctx context.Context) error {
 //		if len(extraHttpHeaders) == 0 {
-//			logger.Debug("no extra HTTP headers")
+//			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 {
@@ -326,9 +326,9 @@ func userAgentOverride(logger *zap.Logger, userAgent string) chromedp.ActionFunc
 //	}
 //}
 
-func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent bool) chromedp.ActionFunc {
+func navigateActionFunc(logger *slog.Logger, url string, skipNetworkIdleEvent 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,7 +344,7 @@ func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent boo
 		if !skipNetworkIdleEvent {
 			waitFunc = append(waitFunc, waitForEventNetworkIdle(ctx, logger))
 		} else {
-			logger.Debug("skipping network idle event")
+			logger.DebugContext(ctx, "skipping network idle event")
 		}
 
 		err = runBatch(
@@ -360,11 +360,11 @@ func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent boo
 	}
 }
 
-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
 		}
 
@@ -373,7 +373,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{
@@ -391,7 +391,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 {
@@ -399,7 +399,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
 		}
 
@@ -423,10 +423,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
 		}
 
@@ -437,12 +437,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 {
@@ -464,21 +464,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():
@@ -489,21 +489,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 {
@@ -531,14 +531,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,8 @@ import (
 	"syscall"
 
 	"github.com/barasher/go-exiftool"
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -74,64 +76,118 @@ 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 {
-	return fmt.Errorf("merge PDFs with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *ExifTool) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("merge PDFs with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // 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) {
-	return nil, fmt.Errorf("split PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *ExifTool) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("split PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // Flatten is not available in this implementation.
-func (engine *ExifTool) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
-	return fmt.Errorf("flatten PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *ExifTool) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("flatten PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Convert is not available in this implementation.
-func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-	return fmt.Errorf("convert PDF to '%+v' with ExifTool: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *ExifTool) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("convert PDF to '%+v' with ExifTool: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // 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) {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
 	if err != nil {
-		return nil, fmt.Errorf("new ExifTool: %w", err)
+		err = fmt.Errorf("new ExifTool: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	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)
 
 	fileMetadata := exifTool.ExtractMetadata(inputPath)
 	if fileMetadata[0].Err != nil {
-		return nil, fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+		err = fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	return fileMetadata[0].Fields, nil
 }
 
 // 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 {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	exifTool, err := exiftool.NewExiftool(exiftool.SetExiftoolBinaryPath(engine.binPath))
 	if err != nil {
-		return fmt.Errorf("new ExifTool: %w", err)
+		err = fmt.Errorf("new ExifTool: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	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)
 
 	fileMetadata := exifTool.ExtractMetadata(inputPath)
 	if fileMetadata[0].Err != nil {
-		return fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+		err = fmt.Errorf("read metadata with ExitfTool: %w", fileMetadata[0].Err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	// Define a list of derived, system, or computed tags that ExifTool
@@ -175,7 +231,10 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 					strs[i] = str
 					continue
 				}
-				return fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeFor[[]any](), gotenberg.ErrPdfEngineMetadataValueNotSupported)
+				err = fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeFor[[]any](), gotenberg.ErrPdfEngineMetadataValueNotSupported)
+				span.RecordError(err)
+				span.SetStatus(codes.Error, err.Error())
+				return err
 			}
 			fileMetadata[0].SetStrings(key, strs)
 		case bool:
@@ -191,36 +250,50 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 		// TODO: support more complex cases, e.g., arrays and nested objects
 		// 	(limitations in underlying library).
 		default:
-			return fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeOf(val), gotenberg.ErrPdfEngineMetadataValueNotSupported)
+			err = fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeOf(val), gotenberg.ErrPdfEngineMetadataValueNotSupported)
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
+			return err
 		}
 	}
 
 	exifTool.WriteMetadata(fileMetadata)
 	if fileMetadata[0].Err != nil {
-		return fmt.Errorf("write PDF metadata with ExifTool: %w", fileMetadata[0].Err)
+		err = fmt.Errorf("write PDF metadata with ExifTool: %w", fileMetadata[0].Err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	return nil
 }
 
-// WriteBookmarks is not available in this implementation.
-func (engine *ExifTool) WriteBookmarks(ctx context.Context, logger *zap.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) {
-	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 {
-	return fmt.Errorf("encrypt PDF using ExifTool: %w", gotenberg.ErrPdfEncryptionNotSupported)
+func (engine *ExifTool) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("encrypt PDF using ExifTool: %w", gotenberg.ErrPdfEncryptionNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
-// EmbedFiles is not available in this implementation.
-func (engine *ExifTool) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
-	return fmt.Errorf("embed files with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+// AddAttachments is not available in this implementation.
+func (engine *ExifTool) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "ExifTool.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("add attachments with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Interface guards.

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/codes"
+	"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,7 +47,7 @@ type Api struct {
 	autoStart bool
 	args      libreOfficeArguments
 
-	logger      *zap.Logger
+	logger      *slog.Logger
 	libreOffice libreOffice
 	supervisor  gotenberg.ProcessSupervisor
 }
@@ -187,7 +189,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
 }
 
@@ -241,20 +243,42 @@ 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)
 
+	// OpenTelemetry.
+	meter := gotenberg.Meter()
+	_, 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 {
+			val := a.supervisor.RestartsCount()
+			o.Observe(val)
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create process restarts observable counter: %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 {
+			val := a.supervisor.ReqQueueSize()
+			o.Observe(val)
+			return nil
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("create requests queue size observable gauge: %w", err)
+	}
+
 	return nil
 }
 
@@ -303,7 +327,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()
 
@@ -332,26 +356,6 @@ func (a *Api) Debug() map[string]any {
 	return debug
 }
 
-// Metrics returns the metrics.
-func (a *Api) Metrics() ([]gotenberg.Metric, error) {
-	return []gotenberg.Metric{
-		{
-			Name:        "libreoffice_requests_queue_size",
-			Description: "Current number of LibreOffice conversion requests waiting to be treated.",
-			Read: func() float64 {
-				return float64(a.supervisor.ReqQueueSize())
-			},
-		},
-		{
-			Name:        "libreoffice_restarts_count",
-			Description: "Current number of LibreOffice restarts.",
-			Read: func() float64 {
-				return float64(a.supervisor.RestartsCount())
-			},
-		},
-	}, nil
-}
-
 // Checks adds a health check that verifies if LibreOffice is healthy.
 func (a *Api) Checks() ([]health.CheckerOption, error) {
 	return []health.CheckerOption{
@@ -402,7 +406,10 @@ 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "LibreOffice.Pdf")
+	defer span.End()
+
 	err := a.supervisor.Run(ctx, logger, func() error {
 		return a.libreOffice.pdf(ctx, logger, inputPath, outputPath, options)
 	})
@@ -413,11 +420,20 @@ func (a *Api) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath
 
 	// See https://github.com/gotenberg/gotenberg/issues/639.
 	if errors.Is(err, ErrCoreDumped) {
-		logger.Debug(fmt.Sprintf("got a '%s' error, retry conversion", err))
-		return a.Pdf(ctx, logger, inputPath, outputPath, options)
+		logger.DebugContext(ctx, fmt.Sprintf("got a '%s' error, retry conversion", err))
+		err = a.Pdf(ctx, logger, inputPath, outputPath, options)
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
+		}
+		return err
 	}
 
-	return fmt.Errorf("supervisor run task: %w", err)
+	err = fmt.Errorf("supervisor run task: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+
+	return err
 }
 
 // Extensions returns the file extensions available for conversions.
@@ -559,13 +575,12 @@ func (a *Api) Extensions() []string {
 
 // Interface guards.
 var (
-	_ gotenberg.Module          = (*Api)(nil)
-	_ gotenberg.Provisioner     = (*Api)(nil)
-	_ gotenberg.Validator       = (*Api)(nil)
-	_ gotenberg.App             = (*Api)(nil)
-	_ gotenberg.Debuggable      = (*Api)(nil)
-	_ gotenberg.MetricsProvider = (*Api)(nil)
-	_ api.HealthChecker         = (*Api)(nil)
-	_ Uno                       = (*Api)(nil)
-	_ Provider                  = (*Api)(nil)
+	_ gotenberg.Module      = (*Api)(nil)
+	_ gotenberg.Provisioner = (*Api)(nil)
+	_ gotenberg.Validator   = (*Api)(nil)
+	_ gotenberg.App         = (*Api)(nil)
+	_ gotenberg.Debuggable  = (*Api)(nil)
+	_ api.HealthChecker     = (*Api)(nil)
+	_ Uno                   = (*Api)(nil)
+	_ Provider              = (*Api)(nil)
 )

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,17 @@ import (
 	"sync/atomic"
 	"time"
 
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	semconv "go.opentelemetry.io/otel/semconv/v1.39.0"
+	"go.opentelemetry.io/otel/trace"
 
 	"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 +52,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 +90,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(ctx, "got exit code 81, e.g., LibreOffice first start")
 
 	// Second start (daemon).
 	cmd = gotenberg.Command(logger, p.arguments.binPath, args...)
@@ -123,7 +127,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(ctx, fmt.Sprintf("close connection after health checking the LibreOffice: %v", err))
 			}
 
 			break
@@ -148,19 +152,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(ctx, "waiting for the LibreOffice socket to be available...")
 
 	for {
 		select {
@@ -169,7 +173,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(ctx, "LibreOffice socket available")
 			success = true
 
 			return nil
@@ -179,7 +183,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 +196,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 +225,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 +241,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 +250,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 +263,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")
 	}
 
@@ -332,14 +335,35 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 
 	args = append(args, "--output", outputPath, inputPath)
 
-	cmd, err := gotenberg.CommandContext(ctx, logger, p.arguments.unoBinPath, args...)
+	p.cfgMu.RLock()
+	clientCtx, clientSpan := gotenberg.Tracer().Start(ctx, "uno.execute",
+		trace.WithSpanKind(trace.SpanKindClient),
+		trace.WithAttributes(
+			semconv.ServerAddress("127.0.0.1"),
+			semconv.ServerPort(p.socketPort),
+			semconv.ServicePeerName("libreoffice"),
+			// Legacy attribute for older APMs (Datadog, Jaeger) to draw the
+			// dependency graph.
+			attribute.String("peer.service", "libreoffice"),
+		),
+	)
+	p.cfgMu.RUnlock()
+
+	cmd, err := gotenberg.CommandContext(clientCtx, logger, p.arguments.unoBinPath, args...)
 	if err != nil {
 		return fmt.Errorf("create uno command: %w", err)
 	}
 
-	logger.Debug(fmt.Sprintf("print to PDF with: %+v", options))
+	logger.DebugContext(clientCtx, fmt.Sprintf("print to PDF with: %+v", options))
 
 	exitCode, err := cmd.Exec()
+	if err != nil {
+		clientSpan.RecordError(err)
+		clientSpan.SetStatus(codes.Error, err.Error())
+	}
+
+	clientSpan.End()
+
 	if err == nil {
 		return 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,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
@@ -47,25 +49,55 @@ 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 {
-	return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // 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) {
-	return nil, fmt.Errorf("split PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *LibreOfficePdfEngine) Split(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("split PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // Flatten is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
-	return fmt.Errorf("flatten PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *LibreOfficePdfEngine) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("flatten PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Convert converts the given PDF to a specific PDF format. Currently, only the
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	opts := api.DefaultOptions()
 	opts.PdfFormats = formats
 	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, opts)
@@ -75,40 +107,73 @@ func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Log
 	}
 
 	if errors.Is(err, api.ErrInvalidPdfFormats) {
-		return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, gotenberg.ErrPdfFormatNotSupported)
+		err = fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, gotenberg.ErrPdfFormatNotSupported)
+	} else {
+		err = fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, err)
 	}
 
-	return fmt.Errorf("convert PDF to '%+v' with LibreOffice: %w", formats, err)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
-	return nil, fmt.Errorf("read PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *LibreOfficePdfEngine) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("read PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
-	return fmt.Errorf("write PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+func (engine *LibreOfficePdfEngine) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
 
-// WriteBookmarks is not available in this implementation.
-func (engine *LibreOfficePdfEngine) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
-	return fmt.Errorf("write PDF bookmarks with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+	err := fmt.Errorf("write PDF metadata with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
 
-// ReadBookmarks is not available in this implementation.
-func (engine *LibreOfficePdfEngine) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
-	return nil, fmt.Errorf("read PDF bookmarks with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	return err
 }
 
 // Encrypt is not available in this implementation.
-func (engine *LibreOfficePdfEngine) Encrypt(ctx context.Context, logger *zap.Logger, inputPath, userPassword, ownerPassword string) error {
-	return fmt.Errorf("encrypt PDF using LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *LibreOfficePdfEngine) Encrypt(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("encrypt PDF using LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
-// EmbedFiles is not available in this implementation.
-func (engine *LibreOfficePdfEngine) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
-	return fmt.Errorf("embed files with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+// AddAttachments is not available in this implementation.
+func (engine *LibreOfficePdfEngine) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "LibreOfficePdfEngine.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("add attachments with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Interface guards.

pkg/modules/libreoffice/routes.go

@@ -31,7 +31,7 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 			pdfFormats := pdfengines.FormDataPdfFormats(form)
 			metadata := pdfengines.FormDataPdfMetadata(form, false)
 			userPassword, ownerPassword := pdfengines.FormDataPdfEncrypt(form)
-			embedPaths := pdfengines.FormDataPdfEmbeds(form)
+			attachmentsPaths := pdfengines.FormDataPdfAttachments(form)
 
 			zeroValuedSplitMode := gotenberg.SplitMode{}
 
@@ -253,9 +253,9 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}
 
-			err = pdfengines.EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
+			err = pdfengines.AddAttachmentsStub(ctx, engine, attachmentsPaths, outputPaths)
 			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
+				return fmt.Errorf("add attachments into PDFs: %w", err)
 			}
 
 			err = pdfengines.WriteMetadataStub(ctx, engine, metadata, outputPaths)

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

@@ -1,11 +1,10 @@
 package pdfcpu
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -13,7 +12,8 @@ import (
 	"strings"
 	"syscall"
 
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -28,16 +28,6 @@ type PdfCpu struct {
 	binPath string
 }
 
-type pdfcpuBookmark struct {
-	Title    string           `json:"title"`
-	Page     int              `json:"page"`
-	Children []pdfcpuBookmark `json:"kids,omitempty"`
-}
-
-type pdfcpuBookmarks struct {
-	Bookmarks []pdfcpuBookmark `json:"bookmarks"`
-}
-
 // Descriptor returns a [PdfCpu]'s module descriptor.
 func (engine *PdfCpu) Descriptor() gotenberg.ModuleDescriptor {
 	return gotenberg.ModuleDescriptor{
@@ -95,14 +85,20 @@ 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfCpu.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	args := make([]string, 0, 2+len(inputPaths))
 	args = append(args, "merge", outputPath)
 	args = append(args, inputPaths...)
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
@@ -110,11 +106,19 @@ func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths
 		return nil
 	}
 
-	return fmt.Errorf("merge PDFs with pdfcpu: %w", err)
+	err = fmt.Errorf("merge PDFs with pdfcpu: %w", err)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+	return err
 }
 
 // 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) {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfCpu.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var args []string
 
 	switch mode.Mode {
@@ -128,17 +132,26 @@ func (engine *PdfCpu) Split(ctx context.Context, logger *zap.Logger, mode gotenb
 		}
 		args = append(args, "extract", "-mode", "page", "-pages", mode.Span, inputPath, outputDirPath)
 	default:
-		return nil, fmt.Errorf("split PDFs using mode '%s' with pdfcpu: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		err := fmt.Errorf("split PDFs using mode '%s' with pdfcpu: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return nil, fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return nil, fmt.Errorf("split PDFs with pdfcpu: %w", err)
+		err = fmt.Errorf("split PDFs with pdfcpu: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	var outputPaths []string
@@ -155,7 +168,10 @@ func (engine *PdfCpu) Split(ctx context.Context, logger *zap.Logger, mode gotenb
 		return nil
 	})
 	if err != nil {
-		return nil, fmt.Errorf("walk directory to find resulting PDFs from split with pdfcpu: %w", err)
+		err = fmt.Errorf("walk directory to find resulting PDFs from split with pdfcpu: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	sort.Sort(digitSuffixSort(outputPaths))
@@ -164,167 +180,72 @@ 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 {
-	return fmt.Errorf("flatten PDF with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfCpu) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfCpu.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("flatten PDF with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Convert is not available in this implementation.
-func (engine *PdfCpu) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-	return fmt.Errorf("convert PDF to '%+v' with pdfcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfCpu) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfCpu.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("convert PDF to '%+v' with pdfcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
-	return nil, fmt.Errorf("read PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfCpu) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfCpu.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("read PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
-	return fmt.Errorf("write PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfCpu.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("write PDF metadata with pdfcpu: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
-// 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) {
-	tmpPath := fmt.Sprintf("%s.read.json", inputPath)
-	args := []string{"bookmarks", "export", inputPath, tmpPath}
-	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
-	if err != nil {
-		return nil, fmt.Errorf("create command: %w", err)
-	}
+// AddAttachments adds attachments into a PDF. All files are attached as
+// file attachments without modifying the main PDF content.
+func (engine *PdfCpu) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfCpu.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
 
-	defer func() {
-		err := os.Remove(tmpPath)
-		if err != nil && !os.IsNotExist(err) {
-			logger.Error(fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
-		}
-	}()
-
-	_, cmdErr := cmd.Exec()
-
-	// Check file existence and size.
-	info, statErr := os.Stat(tmpPath)
-
-	if cmdErr != nil {
-		// If the file wasn't created, or it was created but is 0 bytes,
-		// it means pdfcpu had no bookmarks to write.
-		if os.IsNotExist(statErr) || (statErr == nil && info.Size() == 0) {
-			return make([]gotenberg.Bookmark, 0), nil
-		}
-
-		// Fallback: Check the error string just in case pdfcpu failed without
-		// touching the file.
-		if strings.Contains(strings.ToLower(cmdErr.Error()), "no bookmarks") {
-			return make([]gotenberg.Bookmark, 0), nil
-		}
-		return nil, fmt.Errorf("read bookmarks with pdfcpu: %w", cmdErr)
-	}
-
-	// If cmd succeeded, but output a 0-byte file anyway.
-	if info != nil && info.Size() == 0 {
-		return make([]gotenberg.Bookmark, 0), nil
-	}
-
-	// Read the file content.
-	jsonBytes, err := os.ReadFile(tmpPath)
-	if err != nil {
-		return nil, fmt.Errorf("read temporary bookmarks JSON file: %w", err)
-	}
-
-	// Check if the content is just empty whitespace.
-	if len(bytes.TrimSpace(jsonBytes)) == 0 {
-		return make([]gotenberg.Bookmark, 0), nil
-	}
-
-	var data pdfcpuBookmarks
-	err = json.Unmarshal(jsonBytes, &data)
-	if err != nil {
-		return nil, fmt.Errorf("unmarshal bookmarks: %w", err)
-	}
-
-	// Safety check: Does the parsed JSON actually contain bookmarks?
-	if len(data.Bookmarks) == 0 {
-		return make([]gotenberg.Bookmark, 0), nil
-	}
-
-	var mapBookmarks func(bookmarks []pdfcpuBookmark) []gotenberg.Bookmark
-	mapBookmarks = func(bookmarks []pdfcpuBookmark) []gotenberg.Bookmark {
-		res := make([]gotenberg.Bookmark, len(bookmarks))
-		for i, b := range bookmarks {
-			res[i] = gotenberg.Bookmark{
-				Title:    b.Title,
-				Page:     b.Page,
-				Children: mapBookmarks(b.Children),
-			}
-		}
-		return res
-	}
-
-	return mapBookmarks(data.Bookmarks), nil
-}
-
-// 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 {
-	if len(bookmarks) == 0 {
-		return nil
-	}
-
-	var mapBookmarks func(bookmarks []gotenberg.Bookmark) []pdfcpuBookmark
-	mapBookmarks = func(bookmarks []gotenberg.Bookmark) []pdfcpuBookmark {
-		res := make([]pdfcpuBookmark, len(bookmarks))
-		for i, b := range bookmarks {
-			res[i] = pdfcpuBookmark{
-				Title:    b.Title,
-				Page:     b.Page,
-				Children: mapBookmarks(b.Children),
-			}
-		}
-		return res
-	}
-
-	data := pdfcpuBookmarks{
-		Bookmarks: mapBookmarks(bookmarks),
-	}
-
-	jsonBytes, err := json.Marshal(data)
-	if err != nil {
-		return fmt.Errorf("marshal bookmarks: %w", err)
-	}
-
-	tmpPath := fmt.Sprintf("%s.json", inputPath)
-	err = os.WriteFile(tmpPath, jsonBytes, 0o600)
-	if err != nil {
-		return fmt.Errorf("write temporary bookmarks JSON file: %w", err)
-	}
-
-	defer func() {
-		err := os.Remove(tmpPath)
-		if err != nil {
-			logger.Error(fmt.Sprintf("remove temporary bookmarks JSON file: %v", err))
-		}
-	}()
-
-	args := []string{"bookmarks", "import", "-replace", inputPath, tmpPath, inputPath}
-	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
-	if err != nil {
-		return fmt.Errorf("create command: %w", err)
-	}
-
-	_, err = cmd.Exec()
-	if err != nil {
-		return fmt.Errorf("write bookmarks with pdfcpu: %w", err)
-	}
-
-	return nil
-}
-
-// 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 {
 	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("attaching %d file(s) to %s: %v", len(filePaths), inputPath, filePaths))
 
 	args := make([]string, 0, 3+len(filePaths))
 	args = append(args, "attachments", "add", inputPath)
@@ -332,21 +253,33 @@ func (engine *PdfCpu) EmbedFiles(ctx context.Context, logger *zap.Logger, filePa
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command for attaching files: %w", err)
+		err = fmt.Errorf("create command for attaching files: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return fmt.Errorf("attach files with pdfcpu: %w", err)
+		err = fmt.Errorf("attach files with pdfcpu: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	return nil
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfCpu.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	if userPassword == "" {
-		return errors.New("user password cannot be empty")
+		err := errors.New("user password cannot be empty")
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	if ownerPassword == "" {
@@ -363,12 +296,18 @@ func (engine *PdfCpu) Encrypt(ctx context.Context, logger *zap.Logger, inputPath
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return fmt.Errorf("encrypt PDF with pdfcpu: %w", err)
+		err = fmt.Errorf("encrypt PDF with pdfcpu: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	return nil

pkg/modules/pdfengines/multi.go

@@ -1,27 +1,28 @@
+//nolint:dupl
 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"
 )
 
 type multiPdfEngines struct {
-	mergeEngines          []gotenberg.PdfEngine
-	splitEngines          []gotenberg.PdfEngine
-	flattenEngines        []gotenberg.PdfEngine
-	convertEngines        []gotenberg.PdfEngine
-	readMetadataEngines   []gotenberg.PdfEngine
-	writeMetadataEngines  []gotenberg.PdfEngine
-	passwordEngines       []gotenberg.PdfEngine
-	embedEngines          []gotenberg.PdfEngine
-	readBookmarksEngines  []gotenberg.PdfEngine
-	writeBookmarksEngines []gotenberg.PdfEngine
+	mergeEngines         []gotenberg.PdfEngine
+	splitEngines         []gotenberg.PdfEngine
+	flattenEngines       []gotenberg.PdfEngine
+	convertEngines       []gotenberg.PdfEngine
+	readMetadataEngines  []gotenberg.PdfEngine
+	writeMetadataEngines []gotenberg.PdfEngine
+	passwordEngines      []gotenberg.PdfEngine
+	attachmentsEngines   []gotenberg.PdfEngine
 }
 
 func newMultiPdfEngines(
@@ -32,27 +33,26 @@ func newMultiPdfEngines(
 	readMetadataEngines,
 	writeMetadataEngines,
 	passwordEngines,
-	embedEngines,
-	readBookmarksEngines,
-	writeBookmarksEngines []gotenberg.PdfEngine,
+	attachmentsEngines []gotenberg.PdfEngine,
 ) *multiPdfEngines {
 	return &multiPdfEngines{
-		mergeEngines:          mergeEngines,
-		splitEngines:          splitEngines,
-		flattenEngines:        flattenEngines,
-		convertEngines:        convertEngines,
-		readMetadataEngines:   readMetadataEngines,
-		writeMetadataEngines:  writeMetadataEngines,
-		passwordEngines:       passwordEngines,
-		embedEngines:          embedEngines,
-		readBookmarksEngines:  readBookmarksEngines,
-		writeBookmarksEngines: writeBookmarksEngines,
+		mergeEngines:         mergeEngines,
+		splitEngines:         splitEngines,
+		flattenEngines:       flattenEngines,
+		convertEngines:       convertEngines,
+		readMetadataEngines:  readMetadataEngines,
+		writeMetadataEngines: writeMetadataEngines,
+		passwordEngines:      passwordEngines,
+		attachmentsEngines:   attachmentsEngines,
 	}
 }
 
 // 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 {
+func (multi *multiPdfEngines) Merge(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -72,7 +72,10 @@ 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 {
@@ -82,7 +85,10 @@ 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) {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -108,12 +114,18 @@ 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -133,12 +145,18 @@ 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -158,7 +176,10 @@ 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 {
@@ -168,7 +189,10 @@ 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) {
+func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	var mu sync.Mutex // to safely append errors.
 
@@ -194,12 +218,18 @@ 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
+// WriteMetadata attachments 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -219,73 +249,18 @@ func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Log
 		}
 	}
 
-	return fmt.Errorf("write PDF metadata with multi PDF engines: %w", err)
-}
-
-type readBookmarksResult struct {
-	bookmarks []gotenberg.Bookmark
-	err       error
-}
-
-// 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) {
-	var err error
-	var mu sync.Mutex // to safely append errors.
-
-	for _, engine := range multi.readBookmarksEngines {
-		resultChan := make(chan readBookmarksResult, 1)
-
-		go func(engine gotenberg.PdfEngine) {
-			bookmarks, err := engine.ReadBookmarks(ctx, logger, inputPath)
-			resultChan <- readBookmarksResult{bookmarks: bookmarks, err: err}
-		}(engine)
-
-		select {
-		case result := <-resultChan:
-			if result.err != nil {
-				mu.Lock()
-				err = multierr.Append(err, result.err)
-				mu.Unlock()
-			} else {
-				return result.bookmarks, nil
-			}
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		}
-	}
-
-	return nil, fmt.Errorf("read PDF bookmarks with multi PDF engines: %w", 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 {
-	var err error
-	errChan := make(chan error, 1)
-
-	for _, engine := range multi.writeBookmarksEngines {
-		go func(engine gotenberg.PdfEngine) {
-			errChan <- engine.WriteBookmarks(ctx, logger, inputPath, bookmarks)
-		}(engine)
-
-		select {
-		case writeBookmarksErr := <-errChan:
-			errored := multierr.AppendInto(&err, writeBookmarksErr)
-			if !errored {
-				return nil
-			}
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-
-	return fmt.Errorf("write PDF bookmarks 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
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
@@ -305,23 +280,29 @@ 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 {
+// AddAttachments adds attachments into a PDF using the first available
+// engine that supports file attaching.
+func (multi *multiPdfEngines) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	ctx, span := gotenberg.Tracer().Start(ctx, "multiPdfEngines.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var err error
 	errChan := make(chan error, 1)
 
-	for _, engine := range multi.embedEngines {
+	for _, engine := range multi.attachmentsEngines {
 		go func(engine gotenberg.PdfEngine) {
-			errChan <- engine.EmbedFiles(ctx, logger, filePaths, inputPath)
+			errChan <- engine.AddAttachments(ctx, logger, filePaths, inputPath)
 		}(engine)
 
 		select {
-		case embedErr := <-errChan:
-			errored := multierr.AppendInto(&err, embedErr)
+		case attachmentsErr := <-errChan:
+			errored := multierr.AppendInto(&err, attachmentsErr)
 			if !errored {
 				return nil
 			}
@@ -330,7 +311,10 @@ 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("add attachments into PDF using multi PDF engines: %w", err)
+	span.RecordError(err)
+	span.SetStatus(codes.Error, err.Error())
+	return err
 }
 
 // Interface guards.

pkg/modules/pdfengines/multi_test.go

@@ -0,0 +1,650 @@
+package pdfengines
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+)
+
+func TestMultiPdfEngines_Merge(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: false,
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: false,
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *slog.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Merge(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), nil, "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_Encrypt(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				passwordEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				passwordEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				passwordEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				passwordEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						EncryptMock: func(ctx context.Context, logger *slog.Logger, inputPath, userPassword, ownerPassword string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Encrypt(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), "", "", "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *slog.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := tc.engine.Split(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), gotenberg.SplitMode{}, "", "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_Flatten(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				flattenEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				flattenEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				flattenEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				flattenEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						FlattenMock: func(ctx context.Context, logger *slog.Logger, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Flatten(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_Convert(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.Convert(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), gotenberg.PdfFormats{}, "", "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_ReadMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				readMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return make(map[string]any), nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				readMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return make(map[string]any), nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				readMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return nil, errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				readMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+							return make(map[string]any), nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := tc.engine.ReadMetadata(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestMultiPdfEngines_WriteMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				writeMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				writeMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				writeMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				writeMetadataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+							return nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.engine.WriteMetadata(tc.ctx, slog.New(slog.NewJSONHandler(os.Stdout, nil)), nil, "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}

pkg/modules/pdfengines/pdfengines.go

@@ -28,18 +28,16 @@ func init() {
 // the [api.Router] interface to expose relevant PDF processing routes if
 // enabled.
 type PdfEngines struct {
-	mergeNames          []string
-	splitNames          []string
-	flattenNames        []string
-	convertNames        []string
-	readMetadataNames   []string
-	writeMetadataNames  []string
-	encryptNames        []string
-	embedNames          []string
-	readBookmarksNames  []string
-	writeBookmarksNames []string
-	engines             []gotenberg.PdfEngine
-	disableRoutes       bool
+	mergeNames         []string
+	splitNames         []string
+	flattenNames       []string
+	convertNames       []string
+	readMetadataNames  []string
+	writeMetadataNames []string
+	encryptNames       []string
+	attachmentsNames   []string
+	engines            []gotenberg.PdfEngine
+	disableRoutes      bool
 }
 
 // Descriptor returns a PdfEngines' module descriptor.
@@ -54,19 +52,10 @@ func (mod *PdfEngines) Descriptor() gotenberg.ModuleDescriptor {
 			fs.StringSlice("pdfengines-convert-engines", []string{"libreoffice-pdfengine"}, "Set the PDF engines and their order for the convert feature - empty means all")
 			fs.StringSlice("pdfengines-read-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the read metadata feature - empty means all")
 			fs.StringSlice("pdfengines-write-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the write metadata feature - empty means all")
-			fs.StringSlice("pdfengines-encrypt-engines", []string{"qpdf", "pdftk", "pdfcpu"}, "Set the PDF engines and their order for the password protection feature - empty means all")
-			fs.StringSlice("pdfengines-embed-engines", []string{"pdfcpu"}, "Set the PDF engines and their order for the file embedding feature - empty means all")
-			fs.StringSlice("pdfengines-read-bookmarks-engines", []string{"pdfcpu"}, "Set the PDF engines and their order for the read bookmarks feature - empty means all")
-			fs.StringSlice("pdfengines-write-bookmarks-engines", []string{"pdfcpu"}, "Set the PDF engines and their order for the write bookmarks feature - empty means all")
+			fs.StringSlice("pdfengines-encrypt-engines", []string{"qpdf", "pdfcpu", "pdftk"}, "Set the PDF engines and their order for the password protection feature - empty means all")
+			fs.StringSlice("pdfengines-add-attachments-engines", []string{"pdfcpu"}, "Set the PDF engines and their order for the file attaching feature - empty means all")
 			fs.Bool("pdfengines-disable-routes", false, "Disable the routes")
 
-			// Deprecated flags.
-			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the default PDF engines and their default order - all by default")
-			err := fs.MarkDeprecated("pdfengines-engines", "use other flags for a more granular selection of PDF engines per method")
-			if err != nil {
-				panic(err)
-			}
-
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(PdfEngines) },
@@ -84,9 +73,7 @@ func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 	readMetadataNames := flags.MustStringSlice("pdfengines-read-metadata-engines")
 	writeMetadataNames := flags.MustStringSlice("pdfengines-write-metadata-engines")
 	encryptNames := flags.MustStringSlice("pdfengines-encrypt-engines")
-	embedNames := flags.MustStringSlice("pdfengines-embed-engines")
-	readBookmarksNames := flags.MustStringSlice("pdfengines-read-bookmarks-engines")
-	writeBookmarksNames := flags.MustStringSlice("pdfengines-write-bookmarks-engines")
+	attachmentsNames := flags.MustStringSlice("pdfengines-add-attachments-engines")
 	mod.disableRoutes = flags.MustBool("pdfengines-disable-routes")
 
 	engines, err := ctx.Modules(new(gotenberg.PdfEngine))
@@ -108,7 +95,7 @@ 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))
+	//		logger.WarnContext(ctx, fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
 	//		mod.defaultNames[i] = "libreoffice-pdfengine"
 	//	}
 	//}
@@ -148,19 +135,9 @@ func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 		mod.encryptNames = encryptNames
 	}
 
-	mod.embedNames = defaultNames
-	if len(embedNames) > 0 {
-		mod.embedNames = embedNames
-	}
-
-	mod.readBookmarksNames = defaultNames
-	if len(readBookmarksNames) > 0 {
-		mod.readBookmarksNames = readBookmarksNames
-	}
-
-	mod.writeBookmarksNames = defaultNames
-	if len(writeBookmarksNames) > 0 {
-		mod.writeBookmarksNames = writeBookmarksNames
+	mod.attachmentsNames = defaultNames
+	if len(attachmentsNames) > 0 {
+		mod.attachmentsNames = attachmentsNames
 	}
 
 	return nil
@@ -211,9 +188,7 @@ func (mod *PdfEngines) Validate() error {
 	findNonExistingEngines(mod.readMetadataNames)
 	findNonExistingEngines(mod.writeMetadataNames)
 	findNonExistingEngines(mod.encryptNames)
-	findNonExistingEngines(mod.embedNames)
-	findNonExistingEngines(mod.readBookmarksNames)
-	findNonExistingEngines(mod.writeBookmarksNames)
+	findNonExistingEngines(mod.attachmentsNames)
 
 	if len(nonExistingEngines) == 0 {
 		return nil
@@ -233,9 +208,6 @@ func (mod *PdfEngines) SystemMessages() []string {
 		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[:], " ")),
 	}
 }
 
@@ -263,9 +235,7 @@ func (mod *PdfEngines) PdfEngine() (gotenberg.PdfEngine, error) {
 		engines(mod.readMetadataNames),
 		engines(mod.writeMetadataNames),
 		engines(mod.encryptNames),
-		engines(mod.embedNames),
-		engines(mod.readBookmarksNames),
-		engines(mod.writeBookmarksNames),
+		engines(mod.attachmentsNames),
 	), nil
 }
 
@@ -289,10 +259,8 @@ func (mod *PdfEngines) Routes() ([]api.Route, error) {
 		convertRoute(engine),
 		readMetadataRoute(engine),
 		writeMetadataRoute(engine),
-		readBookmarksRoute(engine),
-		writeBookmarksRoute(engine),
 		encryptRoute(engine),
-		embedRoute(engine),
+		attachmentsRoute(engine),
 	}, nil
 }
 

pkg/modules/pdfengines/routes.go

@@ -84,7 +84,7 @@ func FormDataPdfSplitMode(form *api.FormData, mandatory bool) gotenberg.SplitMod
 }
 
 // FormDataPdfFormats creates [gotenberg.PdfFormats] from the form data.
-// Fallback to the default value if the considered key is not present.
+// Fallback to default value if the considered key is not present.
 func FormDataPdfFormats(form *api.FormData) gotenberg.PdfFormats {
 	var (
 		pdfa  string
@@ -128,44 +128,6 @@ func FormDataPdfMetadata(form *api.FormData, mandatory bool) map[string]any {
 	return metadata
 }
 
-// FormDataPdfBookmarks creates bookmarks from the form data.
-func FormDataPdfBookmarks(form *api.FormData, mandatory bool) any {
-	var bookmarks any
-
-	bookmarksFunc := func(value string) error {
-		if len(value) > 0 {
-			var list []gotenberg.Bookmark
-			err := json.Unmarshal([]byte(value), &list)
-			if err == nil {
-				bookmarks = list
-				return nil
-			}
-
-			var m map[string][]gotenberg.Bookmark
-			err = json.Unmarshal([]byte(value), &m)
-			if err == nil {
-				bookmarks = m
-				return nil
-			}
-
-			return fmt.Errorf("unmarshal bookmarks: %w", err)
-		}
-		return nil
-	}
-
-	if mandatory {
-		form.MandatoryCustom("bookmarks", func(value string) error {
-			return bookmarksFunc(value)
-		})
-	} else {
-		form.Custom("bookmarks", func(value string) error {
-			return bookmarksFunc(value)
-		})
-	}
-
-	return bookmarks
-}
-
 // MergeStub merges given PDFs. If only one input PDF, it does nothing and
 // returns the corresponding input path.
 func MergeStub(ctx *api.Context, engine gotenberg.PdfEngine, inputPaths []string) (string, error) {
@@ -292,49 +254,12 @@ func WriteMetadataStub(ctx *api.Context, engine gotenberg.PdfEngine, metadata ma
 	return nil
 }
 
-// WriteBookmarksStub writes the bookmarks into PDF files. If no bookmarks, it
-// does nothing.
-func WriteBookmarksStub(ctx *api.Context, engine gotenberg.PdfEngine, bookmarks any, inputPaths []string) error {
-	if bookmarks == nil {
-		return nil
-	}
-
-	switch b := bookmarks.(type) {
-	case []gotenberg.Bookmark:
-		if len(b) == 0 {
-			return nil
-		}
-
-		for _, inputPath := range inputPaths {
-			err := engine.WriteBookmarks(ctx, ctx.Log(), inputPath, b)
-			if err != nil {
-				return fmt.Errorf("write bookmarks into '%s': %w", inputPath, err)
-			}
-		}
-	case map[string][]gotenberg.Bookmark:
-		for _, inputPath := range inputPaths {
-			filename := filepath.Base(inputPath)
-			if specificBookmarks, ok := b[filename]; ok {
-				err := engine.WriteBookmarks(ctx, ctx.Log(), inputPath, specificBookmarks)
-				if err != nil {
-					return fmt.Errorf("write bookmarks into '%s': %w", inputPath, err)
-				}
-			}
-		}
-	default:
-		// Should not happen.
-		return fmt.Errorf("bookmarks type '%T' not supported", bookmarks)
-	}
-
-	return nil
-}
-
-// FormDataPdfEmbeds extracts embedded file paths from form data.
-// Only files uploaded with the "embeds" field name are included.
-func FormDataPdfEmbeds(form *api.FormData) []string {
-	var embedPaths []string
-	form.Embeds(&embedPaths)
-	return embedPaths
+// FormDataPdfAttachments extracts attached file paths from form data.
+// Only files uploaded with the "attachments" field name are included.
+func FormDataPdfAttachments(form *api.FormData) []string {
+	var attachmentsPaths []string
+	form.Attachments(&attachmentsPaths)
+	return attachmentsPaths
 }
 
 // FormDataPdfEncrypt extracts encryption parameters from form data.
@@ -360,16 +285,16 @@ func EncryptPdfStub(ctx *api.Context, engine gotenberg.PdfEngine, userPassword,
 	return nil
 }
 
-// EmbedFilesStub embeds files into PDF files.
-func EmbedFilesStub(ctx *api.Context, engine gotenberg.PdfEngine, embedPaths []string, inputPaths []string) error {
-	if len(embedPaths) == 0 {
+// AddAttachmentsStub adds attachments into PDF files.
+func AddAttachmentsStub(ctx *api.Context, engine gotenberg.PdfEngine, attachmentsPaths []string, inputPaths []string) error {
+	if len(attachmentsPaths) == 0 {
 		return nil
 	}
 
 	for _, inputPath := range inputPaths {
-		err := engine.EmbedFiles(ctx, ctx.Log(), embedPaths, inputPath)
+		err := engine.AddAttachments(ctx, ctx.Log(), attachmentsPaths, inputPath)
 		if err != nil {
-			return fmt.Errorf("embed files into PDF '%s': %w", inputPath, err)
+			return fmt.Errorf("add attachments into PDF '%s': %w", inputPath, err)
 		}
 	}
 
@@ -388,9 +313,8 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 			form := ctx.FormData()
 			pdfFormats := FormDataPdfFormats(form)
 			metadata := FormDataPdfMetadata(form, false)
-			bookmarks := FormDataPdfBookmarks(form, false)
 			userPassword, ownerPassword := FormDataPdfEncrypt(form)
-			embedPaths := FormDataPdfEmbeds(form)
+			attachmentsPaths := FormDataPdfAttachments(form)
 
 			var inputPaths []string
 			var flatten bool
@@ -402,13 +326,6 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}
 
-			if b, ok := bookmarks.(map[string][]gotenberg.Bookmark); ok {
-				err = WriteBookmarksStub(ctx, engine, b, inputPaths)
-				if err != nil {
-					return fmt.Errorf("write bookmarks: %w", err)
-				}
-			}
-
 			outputPath := ctx.GeneratePath(".pdf")
 			err = engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
 			if err != nil {
@@ -420,16 +337,9 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("convert PDF: %w", err)
 			}
 
-			err = EmbedFilesStub(ctx, engine, embedPaths, outputPaths)
+			err = AddAttachmentsStub(ctx, engine, attachmentsPaths, outputPaths)
 			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
-			}
-
-			if b, ok := bookmarks.([]gotenberg.Bookmark); ok {
-				err = WriteBookmarksStub(ctx, engine, b, outputPaths)
-				if err != nil {
-					return fmt.Errorf("write bookmarks: %w", err)
-				}
+				return fmt.Errorf("add attachments into PDFs: %w", err)
 			}
 
 			err = WriteMetadataStub(ctx, engine, metadata, outputPaths)
@@ -473,7 +383,7 @@ func splitRoute(engine gotenberg.PdfEngine) api.Route {
 			pdfFormats := FormDataPdfFormats(form)
 			metadata := FormDataPdfMetadata(form, false)
 			userPassword, ownerPassword := FormDataPdfEncrypt(form)
-			embedPaths := FormDataPdfEmbeds(form)
+			attachmentsPaths := FormDataPdfAttachments(form)
 
 			var inputPaths []string
 			var flatten bool
@@ -495,9 +405,9 @@ func splitRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("convert PDFs: %w", err)
 			}
 
-			err = EmbedFilesStub(ctx, engine, embedPaths, convertOutputPaths)
+			err = AddAttachmentsStub(ctx, engine, attachmentsPaths, convertOutputPaths)
 			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
+				return fmt.Errorf("add attachments into PDFs: %w", err)
 			}
 
 			err = WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
@@ -709,83 +619,6 @@ func writeMetadataRoute(engine gotenberg.PdfEngine) api.Route {
 	}
 }
 
-// readBookmarksRoute returns an [api.Route] which returns the bookmarks of PDFs.
-func readBookmarksRoute(engine gotenberg.PdfEngine) api.Route {
-	return api.Route{
-		Method:      http.MethodPost,
-		Path:        "/forms/pdfengines/bookmarks/read",
-		IsMultipart: true,
-		Handler: func(c echo.Context) error {
-			ctx := c.Get("context").(*api.Context)
-
-			var inputPaths []string
-			err := ctx.FormData().
-				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				Validate()
-			if err != nil {
-				return fmt.Errorf("validate form data: %w", err)
-			}
-
-			res := make(map[string][]gotenberg.Bookmark, len(inputPaths))
-			for _, inputPath := range inputPaths {
-				bookmarks, err := engine.ReadBookmarks(ctx, ctx.Log(), inputPath)
-				if err != nil {
-					return fmt.Errorf("read bookmarks: %w", err)
-				}
-
-				res[filepath.Base(inputPath)] = bookmarks
-			}
-
-			err = c.JSON(http.StatusOK, res)
-			if err != nil {
-				if strings.Contains(err.Error(), "request method or response status code does not allow body") {
-					// High probability that the user is using the webhook
-					// feature. It does not make sense for this route.
-					return api.ErrNoOutputFile
-				}
-				return fmt.Errorf("return JSON response: %w", err)
-			}
-
-			return api.ErrNoOutputFile
-		},
-	}
-}
-
-// writeBookmarksRoute returns an [api.Route] which can write bookmarks into PDFs.
-func writeBookmarksRoute(engine gotenberg.PdfEngine) api.Route {
-	return api.Route{
-		Method:      http.MethodPost,
-		Path:        "/forms/pdfengines/bookmarks/write",
-		IsMultipart: true,
-		Handler: func(c echo.Context) error {
-			ctx := c.Get("context").(*api.Context)
-
-			form := ctx.FormData()
-			bookmarks := FormDataPdfBookmarks(form, true)
-
-			var inputPaths []string
-			err := form.
-				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				Validate()
-			if err != nil {
-				return fmt.Errorf("validate form data: %w", err)
-			}
-
-			err = WriteBookmarksStub(ctx, engine, bookmarks, inputPaths)
-			if err != nil {
-				return fmt.Errorf("write bookmarks: %w", err)
-			}
-
-			err = ctx.AddOutputPaths(inputPaths...)
-			if err != nil {
-				return fmt.Errorf("add output paths: %w", err)
-			}
-
-			return nil
-		},
-	}
-}
-
 // encryptRoute returns an [api.Route] which can add password protection to PDFs.
 func encryptRoute(engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
@@ -824,18 +657,17 @@ func encryptRoute(engine gotenberg.PdfEngine) api.Route {
 	}
 }
 
-// embedRoute returns an [api.Route] which can add embedded files to PDFs.
-// TODO: attachments instead?
-func embedRoute(engine gotenberg.PdfEngine) api.Route {
+// attachmentsRoute returns an [api.Route] which can add attached files to PDFs.
+func attachmentsRoute(engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
 		Method:      http.MethodPost,
-		Path:        "/forms/pdfengines/embed",
+		Path:        "/forms/pdfengines/attachments/add",
 		IsMultipart: true,
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
 
 			form := ctx.FormData()
-			embedPaths := FormDataPdfEmbeds(form)
+			attachmentsPaths := FormDataPdfAttachments(form)
 
 			var inputPaths []string
 			err := form.
@@ -844,9 +676,10 @@ func embedRoute(engine gotenberg.PdfEngine) api.Route {
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}
-			err = EmbedFilesStub(ctx, engine, embedPaths, inputPaths)
+
+			err = AddAttachmentsStub(ctx, engine, attachmentsPaths, inputPaths)
 			if err != nil {
-				return fmt.Errorf("embed files into PDFs: %w", err)
+				return fmt.Errorf("add attachments into PDFs: %w", err)
 			}
 
 			err = ctx.AddOutputPaths(inputPaths...)

pkg/modules/pdftk/pdftk.go

@@ -5,12 +5,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"syscall"
 
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -79,42 +81,63 @@ 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) {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfTk.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var args []string
 	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
 
 	switch mode.Mode {
 	case gotenberg.SplitModePages:
 		if !mode.Unify {
-			return nil, fmt.Errorf("split PDFs using mode '%s' without unify with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+			err := fmt.Errorf("split PDFs using mode '%s' without unify with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
+			return nil, err
 		}
 		args = append(args, inputPath, "cat", mode.Span, "output", outputPath)
 	default:
-		return nil, fmt.Errorf("split PDFs using mode '%s' with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		err := fmt.Errorf("split PDFs using mode '%s' with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return nil, fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return nil, fmt.Errorf("split PDFs with PDFtk: %w", err)
+		err = fmt.Errorf("split PDFs with PDFtk: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	return []string{outputPath}, nil
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfTk.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	args := make([]string, 0, 3+len(inputPaths))
 	args = append(args, inputPaths...)
 	args = append(args, "cat", "output", outputPath)
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
@@ -122,47 +145,87 @@ func (engine *PdfTk) Merge(ctx context.Context, logger *zap.Logger, inputPaths [
 		return nil
 	}
 
-	return fmt.Errorf("merge PDFs with PDFtk: %w", err)
+	err = fmt.Errorf("merge PDFs with PDFtk: %w", err)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+	return err
 }
 
 // Flatten is not available in this implementation.
-func (engine *PdfTk) Flatten(ctx context.Context, logger *zap.Logger, inputPath string) error {
-	return fmt.Errorf("flatten PDF with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfTk) Flatten(ctx context.Context, logger *slog.Logger, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfTk.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("flatten PDF with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Convert is not available in this implementation.
-func (engine *PdfTk) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-	return fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfTk) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfTk.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("convert PDF to '%+v' with PDFtk: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
-	return nil, fmt.Errorf("read PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *PdfTk) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfTk.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("read PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
-	return fmt.Errorf("write PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+func (engine *PdfTk) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfTk.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
 
-// WriteBookmarks is not available in this implementation.
-func (engine *PdfTk) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
-	return fmt.Errorf("write PDF bookmarks with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+	err := fmt.Errorf("write PDF metadata with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
 
-// ReadBookmarks is not available in this implementation.
-func (engine *PdfTk) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
-	return nil, fmt.Errorf("read PDF bookmarks with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	return err
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "PdfTk.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	if userPassword == "" {
-		return errors.New("user password cannot be empty")
+		err := errors.New("user password cannot be empty")
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	if ownerPassword == userPassword || ownerPassword == "" {
-		return gotenberg.NewPdfEngineInvalidArgs("pdftk", "both 'userPassword' and 'ownerPassword' must be provided and different. Consider switching to another PDF engine if this behavior does not work with your workflow")
+		err := gotenberg.NewPdfEngineInvalidArgs("pdftk", "both 'userPassword' and 'ownerPassword' must be provided and different. Consider switching to another PDF engine if this behavior does not work with your workflow")
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	// Create a temp output file in the same directory.
@@ -177,25 +240,43 @@ func (engine *PdfTk) Encrypt(ctx context.Context, logger *zap.Logger, inputPath,
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return fmt.Errorf("encrypt PDF with PDFtk: %w", err)
+		err = fmt.Errorf("encrypt PDF with PDFtk: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	err = os.Rename(tmpPath, inputPath)
 	if err != nil {
-		return fmt.Errorf("rename temporary output file with input file: %w", err)
+		err = fmt.Errorf("rename temporary output file with input file: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	return nil
 }
 
-// EmbedFiles is not available in this implementation.
-func (engine *PdfTk) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
-	return fmt.Errorf("embed files with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+// AddAttachments is not available in this implementation.
+func (engine *PdfTk) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "PdfTk.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("add attachments with PDFtk: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // Interface guards.

pkg/modules/prometheus/doc.go

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

pkg/modules/prometheus/prometheus.go

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

pkg/modules/qpdf/qpdf.go

@@ -5,12 +5,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"syscall"
 
-	"go.uber.org/zap"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )
@@ -82,38 +84,56 @@ 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) {
+	ctx, span := gotenberg.Tracer().Start(ctx, "QPdf.Split", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	var args []string
 	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
 
 	switch mode.Mode {
 	case gotenberg.SplitModePages:
 		if !mode.Unify {
-			return nil, fmt.Errorf("split PDFs using mode '%s' without unify with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+			err := fmt.Errorf("split PDFs using mode '%s' without unify with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
+			return nil, err
 		}
 		args = append(args, inputPath)
 		args = append(args, engine.globalArgs...)
 		args = append(args, "--pages", ".", mode.Span)
 		args = append(args, "--", outputPath)
 	default:
-		return nil, fmt.Errorf("split PDFs using mode '%s' with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		err := fmt.Errorf("split PDFs using mode '%s' with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return nil, fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return nil, fmt.Errorf("split PDFs with QPDF: %w", err)
+		err = fmt.Errorf("split PDFs with QPDF: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
 	}
 
 	return []string{outputPath}, nil
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "QPdf.Merge", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	args := make([]string, 0, 4+len(engine.globalArgs)+len(inputPaths))
 	args = append(args, "--empty")
 	args = append(args, engine.globalArgs...)
@@ -123,7 +143,10 @@ func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
@@ -131,12 +154,20 @@ func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []
 		return nil
 	}
 
-	return fmt.Errorf("merge PDFs with QPDF: %w", err)
+	err = fmt.Errorf("merge PDFs with QPDF: %w", err)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+	return err
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "QPdf.Flatten", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	args := make([]string, 0, 4+len(engine.globalArgs))
 	args = append(args, inputPath)
 	args = append(args, "--generate-appearances")
@@ -146,7 +177,10 @@ func (engine *QPdf) Flatten(ctx context.Context, logger *zap.Logger, inputPath s
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
@@ -154,38 +188,66 @@ func (engine *QPdf) Flatten(ctx context.Context, logger *zap.Logger, inputPath s
 		return nil
 	}
 
-	return fmt.Errorf("flatten PDFs with QPDF: %w", err)
+	err = fmt.Errorf("flatten PDFs with QPDF: %w", err)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+	return err
 }
 
 // Convert is not available in this implementation.
-func (engine *QPdf) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-	return fmt.Errorf("convert PDF to '%+v' with QPDF: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *QPdf) Convert(ctx context.Context, logger *slog.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "QPdf.Convert", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("convert PDF to '%+v' with QPDF: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 // ReadMetadata is not available in this implementation.
-func (engine *QPdf) ReadMetadata(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]any, error) {
-	return nil, fmt.Errorf("read PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+func (engine *QPdf) ReadMetadata(ctx context.Context, logger *slog.Logger, inputPath string) (map[string]any, error) {
+	_, span := gotenberg.Tracer().Start(ctx, "QPdf.ReadMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("read PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return nil, err
 }
 
 // WriteMetadata is not available in this implementation.
-func (engine *QPdf) WriteMetadata(ctx context.Context, logger *zap.Logger, metadata map[string]any, inputPath string) error {
-	return fmt.Errorf("write PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+func (engine *QPdf) WriteMetadata(ctx context.Context, logger *slog.Logger, metadata map[string]any, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "QPdf.WriteMetadata", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
 
-// WriteBookmarks is not available in this implementation.
-func (engine *QPdf) WriteBookmarks(ctx context.Context, logger *zap.Logger, inputPath string, bookmarks []gotenberg.Bookmark) error {
-	return fmt.Errorf("write PDF bookmarks with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
-}
+	err := fmt.Errorf("write PDF metadata with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
 
-// ReadBookmarks is not available in this implementation.
-func (engine *QPdf) ReadBookmarks(ctx context.Context, logger *zap.Logger, inputPath string) ([]gotenberg.Bookmark, error) {
-	return nil, fmt.Errorf("read PDF bookmarks with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	return err
 }
 
 // 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 {
+	ctx, span := gotenberg.Tracer().Start(ctx, "QPdf.Encrypt", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
 	if userPassword == "" {
-		return errors.New("user password cannot be empty")
+		err := errors.New("user password cannot be empty")
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	if ownerPassword == "" {
@@ -200,20 +262,35 @@ func (engine *QPdf) Encrypt(ctx context.Context, logger *zap.Logger, inputPath,
 
 	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
 	if err != nil {
-		return fmt.Errorf("create command: %w", err)
+		err = fmt.Errorf("create command: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	_, err = cmd.Exec()
 	if err != nil {
-		return fmt.Errorf("encrypt PDF with QPDF: %w", err)
+		err = fmt.Errorf("encrypt PDF with QPDF: %w", err)
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return err
 	}
 
 	return nil
 }
 
-// EmbedFiles is not available in this implementation.
-func (engine *QPdf) EmbedFiles(ctx context.Context, logger *zap.Logger, filePaths []string, inputPath string) error {
-	return fmt.Errorf("embed files with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+// AddAttachments is not available in this implementation.
+func (engine *QPdf) AddAttachments(ctx context.Context, logger *slog.Logger, filePaths []string, inputPath string) error {
+	_, span := gotenberg.Tracer().Start(ctx, "QPdf.AddAttachments", trace.WithSpanKind(trace.SpanKindInternal))
+	defer span.End()
+
+	err := fmt.Errorf("add attachments with QPDF: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	}
+
+	return err
 }
 
 var (

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/propagation"
+	"go.opentelemetry.io/otel/trace"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
+	semconvutil "github.com/gotenberg/gotenberg/v8/pkg/gotenberg/semconv"
 )
 
 // 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 http.Header, errored bool) error {
 	url := c.url
 	if errored {
 		url = c.errorUrl
@@ -37,7 +44,7 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 		method = c.errorMethod
 	}
 
-	req, err := retryablehttp.NewRequest(method, url, body)
+	req, err := retryablehttp.NewRequestWithContext(ctx, method, url, body)
 	if err != nil {
 		return fmt.Errorf("create '%s' request to '%s': %w", method, url, err)
 	}
@@ -51,33 +58,53 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 
 	// Middleware caller's headers > extra HTTP headers from the user.
 
-	contentLength, ok := headers[echo.HeaderContentLength]
-	if ok {
-		// Golang "http" package should automatically calculate the size of the
-		// body. But when using a buffered file reader, it does not work.
-		// Worse, the "Content-Length" header is also removed. Therefore,
-		// to keep this valuable information, we have to trust the caller
-		// by reading the value of the "Content-Length" entry and set it as the
-		// content length of the request. It's kinda suboptimal, but hey, at
-		// least it works.
+	contentLength := headers.Get(echo.HeaderContentLength)
+	// Golang "http" package should automatically calculate the size of the
+	// body. But when using a buffered file reader, it does not work.
+	// Worse, the "Content-Length" header is also removed. Therefore,
+	// to keep this valuable information, we have to trust the caller
+	// by reading the value of the "Content-Length" entry and set it as the
+	// content length of the request. It's kinda suboptimal, but hey, at
+	// least it works.
 
-		bodySize, err := strconv.ParseInt(contentLength, 10, 64)
-		if err != nil {
-			return fmt.Errorf("parse content length entry: %w", err)
-		}
-
-		req.ContentLength = bodySize
+	bodySize, err := strconv.ParseInt(contentLength, 10, 64)
+	if err != nil {
+		return fmt.Errorf("parse content length entry: %w", err)
 	}
 
-	for key, value := range headers {
-		req.Header.Set(key, value)
+	req.ContentLength = bodySize
+
+	for key := range headers {
+		req.Header.Set(key, headers.Get(key))
 	}
 
+	// OpenTelemetry.
+	meter := gotenberg.Meter()
+	semconvClient := semconvutil.NewHTTPClient(meter)
+
+	tracer := gotenberg.Tracer()
+	spanName := fmt.Sprintf("%s Webhook", req.Method)
+	if errored {
+		spanName = fmt.Sprintf("%s Webhook Error", req.Method)
+	}
+	ctx, span := tracer.Start(ctx, spanName,
+		trace.WithSpanKind(trace.SpanKindClient),
+		trace.WithAttributes(semconvClient.RequestTraceAttrs(req.Request)...),
+	)
+	defer span.End()
+
+	otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))
+
 	resp, err := c.client.Do(req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(semconvClient.Status(0))
 		return fmt.Errorf("send '%s' request to '%s': %w", method, url, err)
 	}
 
+	span.SetAttributes(semconvClient.ResponseTraceAttrs(resp)...)
+	span.SetStatus(semconvClient.Status(resp.StatusCode))
+
 	if resp.StatusCode >= http.StatusBadRequest {
 		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, url, resp.Status)
 	}
@@ -85,7 +112,7 @@ func (c client) send(body io.Reader, headers map[string]string, errored bool) er
 	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 +120,18 @@ 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)
+	fields := make([]any, 5)
+	fields[0] = slog.String("webhook_url", url)
+	fields[1] = slog.String("method", method)
+	fields[2] = slog.Int64("latency", int64(finishTime.Sub(c.startTime)))
+	fields[3] = slog.String("latency_human", finishTime.Sub(c.startTime).String())
+	fields[4] = 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", fields...)
 		return nil
 	}
 
-	c.logger.Info("request to webhook handled", fields...)
-
+	c.logger.InfoContext(ctx, "request to webhook handled", fields...)
 	return nil
 }

pkg/modules/webhook/middleware.go

@@ -15,336 +15,317 @@ import (
 
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/propagation"
 
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )
 
-type sendOutputFileParams struct {
-	ctx              *api.Context
-	outputPath       string
-	extraHttpHeaders map[string]string
-	traceHeader      string
-	trace            string
-	client           *client
-	handleError      func(error)
-}
-
 func webhookMiddleware(w *Webhook) api.Middleware {
 	return api.Middleware{
 		Stack: api.MultipartStack,
 		Handler: func() echo.MiddlewareFunc {
 			return func(next echo.HandlerFunc) echo.HandlerFunc {
-				sendOutputFile := func(params sendOutputFileParams) {
-					outputFile, err := os.Open(params.outputPath)
-					if err != nil {
-						params.ctx.Log().Error(fmt.Sprintf("open output file: %s", err))
-						params.handleError(err)
-						return
-					}
-					defer func() {
-						err := outputFile.Close()
-						if err != nil {
-							params.ctx.Log().Error(fmt.Sprintf("close output file: %s", err))
-						}
-					}()
-
-					fileHeader := make([]byte, 512)
-					_, err = outputFile.Read(fileHeader)
-					if err != nil {
-						params.ctx.Log().Error(fmt.Sprintf("read header of output file: %s", err))
-						params.handleError(err)
-						return
-					}
-
-					fileStat, err := outputFile.Stat()
-					if err != nil {
-						params.ctx.Log().Error(fmt.Sprintf("get stat from output file: %s", err))
-						params.handleError(err)
-						return
-					}
-
-					_, err = outputFile.Seek(0, 0)
-					if err != nil {
-						params.ctx.Log().Error(fmt.Sprintf("reset output file reader: %s", err))
-						params.handleError(err)
-						return
-					}
-
-					headers := map[string]string{
-						echo.HeaderContentType:   http.DetectContentType(fileHeader),
-						echo.HeaderContentLength: strconv.FormatInt(fileStat.Size(), 10),
-						params.traceHeader:       params.trace,
-					}
-					_, 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)
-					if err != nil {
-						params.ctx.Log().Error(fmt.Sprintf("send output file to webhook: %s", err))
-						params.handleError(err)
-					}
-				}
-
 				return func(c echo.Context) error {
 					webhookUrl := c.Request().Header.Get("Gotenberg-Webhook-Url")
 					if webhookUrl == "" {
-						// No webhook URL, call the next middleware in the chain.
 						return next(c)
 					}
 
 					ctx := c.Get("context").(*api.Context)
 					cancel := c.Get("cancel").(context.CancelFunc)
 
-					// Do we have a webhook error URL in case of... error?
-					webhookErrorUrl := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
-					if webhookErrorUrl == "" {
-						return api.WrapError(
-							errors.New("empty webhook error URL"),
-							api.NewSentinelHttpError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
-						)
-					}
-
 					deadline, ok := ctx.Deadline()
 					if !ok {
 						return errors.New("context has no deadline")
 					}
 
-					// Let's check if the webhook URLs are acceptable according to our
-					// allowed/denied lists.
-					err := gotenberg.FilterDeadline(w.allowList, w.denyList, webhookUrl, deadline)
+					// Parse all configurations.
+					cfg, err := parseWebhookConfig(c, w, deadline, webhookUrl)
 					if err != nil {
-						return fmt.Errorf("filter webhook URL: %w", err)
+						return err
 					}
 
-					err = gotenberg.FilterDeadline(w.errorAllowList, w.errorDenyList, webhookErrorUrl, deadline)
-					if err != nil {
-						return fmt.Errorf("filter webhook error URL: %w", err)
-					}
-
-					// Let's check the HTTP methods for calling the webhook URLs.
-					methodFromHeader := func(header string) (string, error) {
-						method := c.Request().Header.Get(header)
-
-						if method == "" {
-							return http.MethodPost, nil
-						}
-
-						method = strings.ToUpper(method)
-
-						switch method {
-						case http.MethodPost:
-							return method, nil
-						case http.MethodPatch:
-							return method, nil
-						case http.MethodPut:
-							return method, nil
-						}
-
-						return "", api.WrapError(
-							fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
-							api.NewSentinelHttpError(
-								http.StatusBadRequest,
-								fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method),
-							),
-						)
-					}
-
-					webhookMethod, err := methodFromHeader("Gotenberg-Webhook-Method")
-					if err != nil {
-						return fmt.Errorf("get method to use for webhook: %w", err)
-					}
-
-					webhookErrorMethod, err := methodFromHeader("Gotenberg-Webhook-Error-Method")
-					if err != nil {
-						return fmt.Errorf("get method to use for webhook error: %w", err)
-					}
-
-					// What about extra HTTP headers?
-					var extraHttpHeaders map[string]string
-
-					extraHttpHeadersJson := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
-					if extraHttpHeadersJson != "" {
-						err = json.Unmarshal([]byte(extraHttpHeadersJson), &extraHttpHeaders)
-						if err != nil {
-							return api.WrapError(
-								fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
-								api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
-							)
-						}
-					}
-
-					// Retrieve values from echo.Context before it gets recycled.
-					// See https://github.com/gotenberg/gotenberg/issues/1000.
+					// Set up Headers and Tracing.
 					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,
-						method:           webhookMethod,
-						errorUrl:         webhookErrorUrl,
-						errorMethod:      webhookErrorMethod,
-						extraHttpHeaders: extraHttpHeaders,
+					headers := make(http.Header)
+					headers.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+					headers.Set(correlationIdHeader, correlationId)
+					otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(headers))
+
+					// Initialize the Webhook Client.
+					webhookClient := &client{
+						url:              cfg.URL,
+						method:           cfg.Method,
+						errorUrl:         cfg.ErrorURL,
+						errorMethod:      cfg.ErrorMethod,
+						extraHttpHeaders: cfg.ExtraHTTPHeaders,
 						startTime:        startTime,
-
 						client: &retryablehttp.Client{
-							HTTPClient: &http.Client{
-								Timeout: w.clientTimeout,
-							},
+							HTTPClient:   &http.Client{Timeout: w.clientTimeout},
 							RetryMax:     w.maxRetry,
 							RetryWaitMin: w.retryMinWait,
 							RetryWaitMax: w.retryMaxWait,
-							Logger:       gotenberg.NewLeveledLogger(ctx.Log()),
+							Logger:       gotenberg.NewLeveledLogger(ctx.Log()).WithContext(ctx),
 							CheckRetry:   retryablehttp.DefaultRetryPolicy,
 							Backoff:      retryablehttp.DefaultBackoff,
 						},
 						logger: ctx.Log(),
 					}
 
-					// This method parses an "asynchronous" error and sends a
-					// request to the webhook error URL with a JSON body
-					// containing the status and the error message.
-					handleError := func(err error) {
-						status, message := api.ParseError(err)
-
-						body := struct {
-							Status  int    `json:"status"`
-							Message string `json:"message"`
-						}{
-							Status:  status,
-							Message: message,
-						}
-
-						b, err := json.Marshal(body)
-						if err != nil {
-							ctx.Log().Error(fmt.Sprintf("marshal JSON: %s", err.Error()))
-							return
-						}
-
-						headers := map[string]string{
-							echo.HeaderContentType: echo.MIMEApplicationJSON,
-							traceHeader:            trace,
-						}
-
-						err = client.send(bytes.NewReader(b), headers, true)
-						if err != nil {
-							ctx.Log().Error(fmt.Sprintf("send error response to webhook: %s", err.Error()))
-						}
+					handleErrFunc := func(err error) {
+						sendWebhookError(ctx, webhookClient, headers, err)
 					}
 
+					// Execute Sync Flow.
 					if w.enableSyncMode {
-						err := next(c)
-						if err != nil {
-							if errors.Is(err, api.ErrNoOutputFile) {
-								errNoOutputFile := fmt.Errorf("%w - the webhook middleware cannot handle the result of this route", err)
-								handleError(api.WrapError(
-									errNoOutputFile,
-									api.NewSentinelHttpError(
-										http.StatusBadRequest,
-										"The webhook middleware can only work with multipart/form-data routes that results in output files",
-									),
-								))
-								return nil
-							}
-							ctx.Log().Error(err.Error())
-							handleError(err)
-							return nil
-						}
-
-						outputPath, err := ctx.BuildOutputFile()
-						if err != nil {
-							ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
-							handleError(err)
-							return nil
-						}
-						// 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,
-						})
-						return c.NoContent(http.StatusNoContent)
+						return handleSyncWebhook(c, next, ctx, webhookClient, headers, cfg.ExtraHTTPHeaders, handleErrFunc)
 					}
 
-					if deadline, ok := ctx.Deadline(); ok {
-						// Create a new context derived from Background (detached from Request)
-						// but with the same deadline as the original context.
-						detachedCtx, detachedCancel := context.WithDeadline(context.Background(), deadline)
-
-						// Replace the embedded context in the api.Context struct.
-						// The modules downstream will now use this detached context.
-						ctx.Context = detachedCtx
-
-						// We must wrap the cancel function.
-						// 1. detachedCancel() cleans up our new detached context.
-						// 2. originalCancel() (captured from c.Get("cancel")) cleans up the working directory.
-						originalCancel := cancel
-						cancel = func() {
-							detachedCancel()
-							originalCancel()
-						}
-					} else {
-						// Fallback if no deadline was set (rare, as newContext enforces it).
-						ctx.Context = context.Background()
-					}
-
-					// As a webhook URL has been given, we handle the request in a
-					// goroutine and return immediately.
-					w.asyncCount.Add(1)
-					go func() {
-						defer cancel()
-						defer w.asyncCount.Add(-1)
-
-						// Call the next middleware in the chain.
-						err := next(c)
-						if err != nil {
-							if errors.Is(err, api.ErrNoOutputFile) {
-								errNoOutputFile := fmt.Errorf("%w - the webhook middleware cannot handle the result of this route", err)
-								handleError(api.WrapError(
-									errNoOutputFile,
-									api.NewSentinelHttpError(
-										http.StatusBadRequest,
-										"The webhook middleware can only work with multipart/form-data routes that results in output files",
-									),
-								))
-								return
-							}
-							// The process failed for whatever reason. Let's send the
-							// details to the webhook.
-							ctx.Log().Error(err.Error())
-							handleError(err)
-							return
-						}
-
-						// No error, let's get to build the output file.
-						outputPath, err := ctx.BuildOutputFile()
-						if err != nil {
-							ctx.Log().Error(fmt.Sprintf("build output file: %s", err))
-							handleError(err)
-							return
-						}
-
-						sendOutputFile(sendOutputFileParams{
-							ctx:              ctx,
-							outputPath:       outputPath,
-							extraHttpHeaders: extraHttpHeaders,
-							traceHeader:      traceHeader,
-							trace:            trace,
-							client:           client,
-							handleError:      handleError,
-						})
-					}()
-
-					return api.ErrAsyncProcess
+					// Execute Async Flow.
+					return handleAsyncWebhook(c, next, w, ctx, cancel, deadline, webhookClient, headers, cfg.ExtraHTTPHeaders, handleErrFunc)
 				}
 			}
 		}(),
 	}
 }
+
+func handleSyncWebhook(c echo.Context, next echo.HandlerFunc, ctx *api.Context, client *client, headers http.Header, extraHeaders map[string]string, handleErr func(error)) error {
+	if err := next(c); err != nil {
+		if errors.Is(err, api.ErrNoOutputFile) {
+			handleErr(api.WrapError(
+				fmt.Errorf("%w - the webhook middleware cannot handle the result of this route", err),
+				api.NewSentinelHttpError(http.StatusBadRequest, "The webhook middleware can only work with multipart/form-data routes that results in output files"),
+			))
+			return nil
+		}
+		ctx.Log().ErrorContext(ctx, err.Error())
+		handleErr(err)
+		return nil
+	}
+
+	outputPath, err := ctx.BuildOutputFile()
+	if err != nil {
+		ctx.Log().ErrorContext(ctx, fmt.Sprintf("build output file: %s", err))
+		handleErr(err)
+		return nil
+	}
+
+	sendOutputFile(sendOutputFileParams{
+		ctx:              ctx,
+		outputPath:       outputPath,
+		extraHttpHeaders: extraHeaders,
+		headers:          headers,
+		client:           client,
+		handleError:      handleErr,
+	})
+	return c.NoContent(http.StatusNoContent)
+}
+
+func handleAsyncWebhook(c echo.Context, next echo.HandlerFunc, w *Webhook, ctx *api.Context, cancel context.CancelFunc, deadline time.Time, client *client, headers http.Header, extraHeaders map[string]string, handleErr func(error)) error {
+	// Detach context for async processing.
+	detachedCtx := context.WithoutCancel(ctx.Context)
+	detachedCtx, detachedCancel := context.WithDeadline(detachedCtx, deadline)
+	ctx.Context = detachedCtx
+
+	originalCancel := cancel
+	cancel = func() {
+		detachedCancel()
+		originalCancel()
+	}
+
+	w.asyncCount.Add(1)
+	go func() {
+		defer cancel()
+		defer w.asyncCount.Add(-1)
+
+		if err := next(c); err != nil {
+			if errors.Is(err, api.ErrNoOutputFile) {
+				handleErr(api.WrapError(
+					fmt.Errorf("%w - the webhook middleware cannot handle the result of this route", err),
+					api.NewSentinelHttpError(http.StatusBadRequest, "The webhook middleware can only work with multipart/form-data routes that results in output files"),
+				))
+				return
+			}
+			ctx.Log().ErrorContext(ctx, err.Error())
+			handleErr(err)
+			return
+		}
+
+		outputPath, err := ctx.BuildOutputFile()
+		if err != nil {
+			ctx.Log().ErrorContext(ctx, fmt.Sprintf("build output file: %s", err))
+			handleErr(err)
+			return
+		}
+
+		sendOutputFile(sendOutputFileParams{
+			ctx:              ctx,
+			outputPath:       outputPath,
+			extraHttpHeaders: extraHeaders,
+			headers:          headers,
+			client:           client,
+			handleError:      handleErr,
+		})
+	}()
+
+	return api.ErrAsyncProcess
+}
+
+type webhookConfig struct {
+	URL              string
+	ErrorURL         string
+	Method           string
+	ErrorMethod      string
+	ExtraHTTPHeaders map[string]string
+}
+
+func parseWebhookConfig(c echo.Context, w *Webhook, deadline time.Time, webhookUrl string) (*webhookConfig, error) {
+	errorUrl := c.Request().Header.Get("Gotenberg-Webhook-Error-Url")
+	if errorUrl == "" {
+		return nil, api.WrapError(
+			errors.New("empty webhook error URL"),
+			api.NewSentinelHttpError(http.StatusBadRequest, "Invalid 'Gotenberg-Webhook-Error-Url' header: empty value or header not provided"),
+		)
+	}
+
+	if err := gotenberg.FilterDeadline(w.allowList, w.denyList, webhookUrl, deadline); err != nil {
+		return nil, fmt.Errorf("filter webhook URL: %w", err)
+	}
+	if err := gotenberg.FilterDeadline(w.errorAllowList, w.errorDenyList, errorUrl, deadline); err != nil {
+		return nil, fmt.Errorf("filter webhook error URL: %w", err)
+	}
+
+	method, err := methodFromHeader(c, "Gotenberg-Webhook-Method")
+	if err != nil {
+		return nil, fmt.Errorf("get method to use for webhook: %w", err)
+	}
+
+	errorMethod, err := methodFromHeader(c, "Gotenberg-Webhook-Error-Method")
+	if err != nil {
+		return nil, fmt.Errorf("get method to use for webhook error: %w", err)
+	}
+
+	var extraHeaders map[string]string
+	if extraJson := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers"); extraJson != "" {
+		if err := json.Unmarshal([]byte(extraJson), &extraHeaders); err != nil {
+			return nil, api.WrapError(
+				fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
+				api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Gotenberg-Webhook-Extra-Http-Headers' header value: %s", err.Error())),
+			)
+		}
+	}
+
+	return &webhookConfig{
+		URL:              webhookUrl,
+		ErrorURL:         errorUrl,
+		Method:           method,
+		ErrorMethod:      errorMethod,
+		ExtraHTTPHeaders: extraHeaders,
+	}, nil
+}
+
+func methodFromHeader(c echo.Context, header string) (string, error) {
+	method := c.Request().Header.Get(header)
+	if method == "" {
+		return http.MethodPost, nil
+	}
+
+	method = strings.ToUpper(method)
+	switch method {
+	case http.MethodPost, http.MethodPatch, http.MethodPut:
+		return method, nil
+	}
+
+	return "", api.WrapError(
+		fmt.Errorf("webhook method '%s' is not '%s', '%s' or '%s'", method, http.MethodPost, http.MethodPatch, http.MethodPut),
+		api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid '%s' header value: expected '%s', '%s' or '%s', but got '%s'", header, http.MethodPost, http.MethodPatch, http.MethodPut, method)),
+	)
+}
+
+func sendWebhookError(ctx *api.Context, c *client, headers http.Header, processErr error) {
+	status, message := api.ParseError(processErr)
+
+	body := struct {
+		Status  int    `json:"status"`
+		Message string `json:"message"`
+	}{
+		Status:  status,
+		Message: message,
+	}
+
+	b, err := json.Marshal(body)
+	if err != nil {
+		ctx.Log().ErrorContext(ctx, fmt.Sprintf("marshal JSON: %s", err.Error()))
+		return
+	}
+
+	headers.Set(echo.HeaderContentLength, strconv.Itoa(len(b)))
+
+	if err := c.send(ctx, bytes.NewReader(b), headers, true); err != nil {
+		ctx.Log().ErrorContext(ctx, fmt.Sprintf("send error response to webhook: %s", err.Error()))
+	}
+}
+
+type sendOutputFileParams struct {
+	ctx              *api.Context
+	outputPath       string
+	extraHttpHeaders map[string]string
+	headers          http.Header
+	client           *client
+	handleError      func(error)
+}
+
+func sendOutputFile(params sendOutputFileParams) {
+	outputFile, err := os.Open(params.outputPath)
+	if err != nil {
+		params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("open output file: %s", err))
+		params.handleError(err)
+		return
+	}
+	defer func() {
+		if err := outputFile.Close(); err != nil {
+			params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("close output file: %s", err))
+		}
+	}()
+
+	fileHeader := make([]byte, 512)
+	_, err = outputFile.Read(fileHeader)
+	if err != nil {
+		params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("read header of output file: %s", err))
+		params.handleError(err)
+		return
+	}
+
+	fileStat, err := outputFile.Stat()
+	if err != nil {
+		params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("get stat from output file: %s", err))
+		params.handleError(err)
+		return
+	}
+
+	_, err = outputFile.Seek(0, 0)
+	if err != nil {
+		params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("reset output file reader: %s", err))
+		params.handleError(err)
+		return
+	}
+
+	params.headers.Set(echo.HeaderContentType, http.DetectContentType(fileHeader))
+	params.headers.Set(echo.HeaderContentLength, strconv.FormatInt(fileStat.Size(), 10))
+
+	_, ok := params.extraHttpHeaders[echo.HeaderContentDisposition]
+	if !ok {
+		params.headers.Set(echo.HeaderContentDisposition, fmt.Sprintf("attachments; filename=%q", params.ctx.OutputFilename(params.outputPath)))
+	}
+
+	err = params.client.send(params.ctx, bufio.NewReader(outputFile), params.headers, false)
+	if err != nil {
+		params.ctx.Log().ErrorContext(params.ctx, fmt.Sprintf("send output file to webhook: %s", err))
+		params.handleError(err)
+	}
+}