// Code generated by gowrap. DO NOT EDIT.
// template: ../../templates/opentelemetry.tmpl
// gowrap: http://github.com/hexdigest/gowrap

package webhooks

import (
	"context"
	"time"

	"github.com/google/uuid"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/trace"

	"github.com/sarathsp06/sparrow/internal/webhooks/store"

	_codes "go.opentelemetry.io/otel/codes"
)

// WebhookServiceInterfaceWithTracing implements WebhookServiceInterface interface instrumented with open telemetry spans
type WebhookServiceInterfaceWithTracing struct {
	WebhookServiceInterface
	_instance      string
	_spanDecorator func(span trace.Span, params, results map[string]any)
}

// NewWebhookServiceInterfaceWithTracing returns WebhookServiceInterfaceWithTracing
func NewWebhookServiceInterfaceWithTracing(base WebhookServiceInterface, instance string, spanDecorator ...func(span trace.Span, params, results map[string]any)) WebhookServiceInterfaceWithTracing {
	d := WebhookServiceInterfaceWithTracing{
		WebhookServiceInterface: base,
		_instance:               instance,
	}

	if len(spanDecorator) > 0 && spanDecorator[0] != nil {
		d._spanDecorator = spanDecorator[0]
	}

	return d
}

// AlertDeliveryConfigured implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) AlertDeliveryConfigured(ctx context.Context) (b1 bool, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.AlertDeliveryConfigured")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx": ctx}, map[string]interface{}{
				"b1":  b1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.AlertDeliveryConfigured(ctx)
}

// CancelRepush implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) CancelRepush(ctx context.Context, scope BatchScope, repushID string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.CancelRepush")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"scope":    scope,
				"repushID": repushID}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.CancelRepush(ctx, scope, repushID)
}

// CancelRetry implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) CancelRetry(ctx context.Context, scope BatchScope, retryID string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.CancelRetry")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"scope":   scope,
				"retryID": retryID}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.CancelRetry(ctx, scope, retryID)
}

// CreateAlertConfig implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) CreateAlertConfig(ctx context.Context, consumer string, webhookID string, email string, eventTypes []string) (ap1 *store.AlertConfig, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.CreateAlertConfig")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"consumer":   consumer,
				"webhookID":  webhookID,
				"email":      email,
				"eventTypes": eventTypes}, map[string]interface{}{
				"ap1": ap1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.CreateAlertConfig(ctx, consumer, webhookID, email, eventTypes)
}

// CreateSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) CreateSubscription(ctx context.Context, webhookID string, eventName string, consumer string, headers map[string]string, method string, timeout int, transformEnabled bool, transformTemplate string, labelFilters map[string]string, settings SubscriptionTemplateSettings) (s1 string, t1 time.Time, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.CreateSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":               ctx,
				"webhookID":         webhookID,
				"eventName":         eventName,
				"consumer":          consumer,
				"headers":           headers,
				"method":            method,
				"timeout":           timeout,
				"transformEnabled":  transformEnabled,
				"transformTemplate": transformTemplate,
				"labelFilters":      labelFilters,
				"settings":          settings}, map[string]interface{}{
				"s1":  s1,
				"t1":  t1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.CreateSubscription(ctx, webhookID, eventName, consumer, headers, method, timeout, transformEnabled, transformTemplate, labelFilters, settings)
}

// CreateWebhook implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) CreateWebhook(ctx context.Context, req WebhookRegistrationRequest) (reg *store.WebhookRegistration, secret string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.CreateWebhook")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx": ctx,
				"req": req}, map[string]interface{}{
				"reg":    reg,
				"secret": secret,
				"err":    err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.CreateWebhook(ctx, req)
}

// DeleteAlertConfig implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) DeleteAlertConfig(ctx context.Context, consumer string, id string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.DeleteAlertConfig")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"consumer": consumer,
				"id":       id}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.DeleteAlertConfig(ctx, consumer, id)
}

// DeleteSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) DeleteSubscription(ctx context.Context, subscriptionID string, consumer string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.DeleteSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"subscriptionID": subscriptionID,
				"consumer":       consumer}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.DeleteSubscription(ctx, subscriptionID, consumer)
}

// ExportEventTypes implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ExportEventTypes(ctx context.Context, sel EventTypeExportSelection) (ea1 []EventTypeDefinition, b1 BundleStamp, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ExportEventTypes")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx": ctx,
				"sel": sel}, map[string]interface{}{
				"ea1": ea1,
				"b1":  b1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ExportEventTypes(ctx, sel)
}

// GetConsumerStats implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetConsumerStats(ctx context.Context, consumer string) (cp1 *ConsumerStatsData, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetConsumerStats")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"consumer": consumer}, map[string]interface{}{
				"cp1": cp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetConsumerStats(ctx, consumer)
}

// GetDeliveryAttempts implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetDeliveryAttempts(ctx context.Context, deliveryID string, consumer string) (wpa1 []*store.WebhookHealthEvent, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetDeliveryAttempts")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"deliveryID": deliveryID,
				"consumer":   consumer}, map[string]interface{}{
				"wpa1": wpa1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetDeliveryAttempts(ctx, deliveryID, consumer)
}

// GetDeliveryStatus implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetDeliveryStatus(ctx context.Context, deliveryID string, consumer string) (wp1 *store.WebhookDelivery, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetDeliveryStatus")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"deliveryID": deliveryID,
				"consumer":   consumer}, map[string]interface{}{
				"wp1": wp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetDeliveryStatus(ctx, deliveryID, consumer)
}

// GetEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetEvent(ctx context.Context, name string) (ep1 *store.EventRegistration, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":  ctx,
				"name": name}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetEvent(ctx, name)
}

// GetEventRecord implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetEventRecord(ctx context.Context, eventID string) (ep1 *store.EventRecord, i1 int32, i2 int32, i3 int32, i4 int32, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetEventRecord")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"eventID": eventID}, map[string]interface{}{
				"ep1": ep1,
				"i1":  i1,
				"i2":  i2,
				"i3":  i3,
				"i4":  i4,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetEventRecord(ctx, eventID)
}

// GetEventTypeVersion implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetEventTypeVersion(ctx context.Context, name string, version int) (ep1 *store.EventRegistrationVersion, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetEventTypeVersion")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"name":    name,
				"version": version}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetEventTypeVersion(ctx, name, version)
}

// GetHealthSummary implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetHealthSummary(ctx context.Context, consumer string) (hp1 *HealthSummaryData, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetHealthSummary")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"consumer": consumer}, map[string]interface{}{
				"hp1": hp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetHealthSummary(ctx, consumer)
}

// GetRepushStatus implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetRepushStatus(ctx context.Context, scope BatchScope, repushID string) (bp1 *store.BatchJob, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetRepushStatus")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"scope":    scope,
				"repushID": repushID}, map[string]interface{}{
				"bp1": bp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetRepushStatus(ctx, scope, repushID)
}

// GetRetryStatus implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetRetryStatus(ctx context.Context, scope BatchScope, retryID string) (bp1 *store.BatchJob, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetRetryStatus")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"scope":   scope,
				"retryID": retryID}, map[string]interface{}{
				"bp1": bp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetRetryStatus(ctx, scope, retryID)
}

// GetSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetSubscription(ctx context.Context, subscriptionID string, consumer string) (ep1 *store.EventSubscription, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"subscriptionID": subscriptionID,
				"consumer":       consumer}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetSubscription(ctx, subscriptionID, consumer)
}

// GetWebhookHealth implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) GetWebhookHealth(ctx context.Context, webhookID string, consumer string) (wp1 *WebhookHealthData, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.GetWebhookHealth")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"webhookID": webhookID,
				"consumer":  consumer}, map[string]interface{}{
				"wp1": wp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.GetWebhookHealth(ctx, webhookID, consumer)
}

// ImportEventTypes implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ImportEventTypes(ctx context.Context, items []EventTypeDefinition, stamp *BundleStamp, opts EventTypeImportOptions) (ep1 *EventTypeImportResult, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ImportEventTypes")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":   ctx,
				"items": items,
				"stamp": stamp,
				"opts":  opts}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ImportEventTypes(ctx, items, stamp, opts)
}

// ListAlertConfigs implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListAlertConfigs(ctx context.Context, consumer string, webhookID string) (apa1 []*store.AlertConfig, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListAlertConfigs")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"consumer":  consumer,
				"webhookID": webhookID}, map[string]interface{}{
				"apa1": apa1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListAlertConfigs(ctx, consumer, webhookID)
}

// ListConsumers implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListConsumers(ctx context.Context, query string, limit int32) (sa1 []string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListConsumers")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":   ctx,
				"query": query,
				"limit": limit}, map[string]interface{}{
				"sa1": sa1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListConsumers(ctx, query, limit)
}

// ListDeliveries implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListDeliveries(ctx context.Context, filter store.DeliveryFilter) (dp1 *DeliveryPage, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListDeliveries")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":    ctx,
				"filter": filter}, map[string]interface{}{
				"dp1": dp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListDeliveries(ctx, filter)
}

// ListEventReports implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListEventReports(ctx context.Context, filter store.EventReportFilter) (ep1 *EventReportPage, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListEventReports")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":    ctx,
				"filter": filter}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListEventReports(ctx, filter)
}

// ListEventTypeVersions implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListEventTypeVersions(ctx context.Context, name string) (epa1 []*store.EventRegistrationVersion, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListEventTypeVersions")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":  ctx,
				"name": name}, map[string]interface{}{
				"epa1": epa1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListEventTypeVersions(ctx, name)
}

// ListEvents implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListEvents(ctx context.Context, activeOnly bool, consumer string, limit int32, offset int32) (epa1 []*store.EventRegistration, i1 int32, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListEvents")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"activeOnly": activeOnly,
				"consumer":   consumer,
				"limit":      limit,
				"offset":     offset}, map[string]interface{}{
				"epa1": epa1,
				"i1":   i1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListEvents(ctx, activeOnly, consumer, limit, offset)
}

// ListSubscriptionTemplateVersions implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListSubscriptionTemplateVersions(ctx context.Context, subscriptionID string, consumer string, limit int) (spa1 []*store.SubscriptionTemplateVersion, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListSubscriptionTemplateVersions")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"subscriptionID": subscriptionID,
				"consumer":       consumer,
				"limit":          limit}, map[string]interface{}{
				"spa1": spa1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListSubscriptionTemplateVersions(ctx, subscriptionID, consumer, limit)
}

// ListSubscriptions implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListSubscriptions(ctx context.Context, consumer string, webhookID string, eventName string, limit int32, offset int32) (epa1 []*store.EventSubscription, i1 int32, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListSubscriptions")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"consumer":  consumer,
				"webhookID": webhookID,
				"eventName": eventName,
				"limit":     limit,
				"offset":    offset}, map[string]interface{}{
				"epa1": epa1,
				"i1":   i1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListSubscriptions(ctx, consumer, webhookID, eventName, limit, offset)
}

// ListSubscriptionsByWebhookIDs implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListSubscriptionsByWebhookIDs(ctx context.Context, webhookIDs []uuid.UUID) (epa1 []*store.EventSubscription, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListSubscriptionsByWebhookIDs")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"webhookIDs": webhookIDs}, map[string]interface{}{
				"epa1": epa1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListSubscriptionsByWebhookIDs(ctx, webhookIDs)
}

// ListWebhooks implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ListWebhooks(ctx context.Context, consumer string, webhookID string, event string, activeOnly bool, health string, limit int32, offset int32) (wpa1 []*store.WebhookRegistration, i1 int32, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ListWebhooks")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"consumer":   consumer,
				"webhookID":  webhookID,
				"event":      event,
				"activeOnly": activeOnly,
				"health":     health,
				"limit":      limit,
				"offset":     offset}, map[string]interface{}{
				"wpa1": wpa1,
				"i1":   i1,
				"err":  err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ListWebhooks(ctx, consumer, webhookID, event, activeOnly, health, limit, offset)
}

// PauseSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) PauseSubscription(ctx context.Context, subscriptionID string, consumer string, reason string) (ep1 *store.EventSubscription, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.PauseSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"subscriptionID": subscriptionID,
				"consumer":       consumer,
				"reason":         reason}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.PauseSubscription(ctx, subscriptionID, consumer, reason)
}

// PauseWebhook implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) PauseWebhook(ctx context.Context, webhookID string, consumer string, reason string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.PauseWebhook")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"webhookID": webhookID,
				"consumer":  consumer,
				"reason":    reason}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.PauseWebhook(ctx, webhookID, consumer, reason)
}

// PushEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) PushEvent(ctx context.Context, consumer string, event string, payload map[string]any, ttlSeconds int64, metadata map[string]string, labels map[string]string, idempotencyKey *string, scheduledAt *time.Time) (eventID string, isDuplicate bool, schemaValid bool, warnings []string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.PushEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"consumer":       consumer,
				"event":          event,
				"payload":        payload,
				"ttlSeconds":     ttlSeconds,
				"metadata":       metadata,
				"labels":         labels,
				"idempotencyKey": idempotencyKey,
				"scheduledAt":    scheduledAt}, map[string]interface{}{
				"eventID":     eventID,
				"isDuplicate": isDuplicate,
				"schemaValid": schemaValid,
				"warnings":    warnings,
				"err":         err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.PushEvent(ctx, consumer, event, payload, ttlSeconds, metadata, labels, idempotencyKey, scheduledAt)
}

// RePushEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RePushEvent(ctx context.Context, eventID string) (s1 string, sa1 []string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RePushEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"eventID": eventID}, map[string]interface{}{
				"s1":  s1,
				"sa1": sa1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RePushEvent(ctx, eventID)
}

// RePushEvents implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RePushEvents(ctx context.Context, scope BatchScope, repushID string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RePushEvents")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":      ctx,
				"scope":    scope,
				"repushID": repushID}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RePushEvents(ctx, scope, repushID)
}

// RegisterEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RegisterEvent(ctx context.Context, name string, description string, schema map[string]any, metadata map[string]string, active bool) (s1 string, t1 time.Time, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RegisterEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":         ctx,
				"name":        name,
				"description": description,
				"schema":      schema,
				"metadata":    metadata,
				"active":      active}, map[string]interface{}{
				"s1":  s1,
				"t1":  t1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RegisterEvent(ctx, name, description, schema, metadata, active)
}

// ResumeSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ResumeSubscription(ctx context.Context, subscriptionID string, consumer string) (rp1 *ResumeResult, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ResumeSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"subscriptionID": subscriptionID,
				"consumer":       consumer}, map[string]interface{}{
				"rp1": rp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ResumeSubscription(ctx, subscriptionID, consumer)
}

// ResumeWebhook implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) ResumeWebhook(ctx context.Context, webhookID string, consumer string) (wp1 *WebhookResumeResult, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.ResumeWebhook")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"webhookID": webhookID,
				"consumer":  consumer}, map[string]interface{}{
				"wp1": wp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.ResumeWebhook(ctx, webhookID, consumer)
}

// RetryDeliveries implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RetryDeliveries(ctx context.Context, scope BatchScope, retryID string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RetryDeliveries")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":     ctx,
				"scope":   scope,
				"retryID": retryID}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RetryDeliveries(ctx, scope, retryID)
}

// RetryDelivery implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RetryDelivery(ctx context.Context, consumer string, deliveryID string, webhookID string, force bool) (sa1 []string, i1 int32, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RetryDelivery")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":        ctx,
				"consumer":   consumer,
				"deliveryID": deliveryID,
				"webhookID":  webhookID,
				"force":      force}, map[string]interface{}{
				"sa1": sa1,
				"i1":  i1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RetryDelivery(ctx, consumer, deliveryID, webhookID, force)
}

// RotateWebhookSecret implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) RotateWebhookSecret(ctx context.Context, webhookID string, consumer string) (s1 string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.RotateWebhookSecret")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"webhookID": webhookID,
				"consumer":  consumer}, map[string]interface{}{
				"s1":  s1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.RotateWebhookSecret(ctx, webhookID, consumer)
}

// SendTestEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) SendTestEvent(ctx context.Context, consumer string, subscriptionID string, eventName string, payload map[string]any) (tp1 *TestEventResult, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.SendTestEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":            ctx,
				"consumer":       consumer,
				"subscriptionID": subscriptionID,
				"eventName":      eventName,
				"payload":        payload}, map[string]interface{}{
				"tp1": tp1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.SendTestEvent(ctx, consumer, subscriptionID, eventName, payload)
}

// TestSubscriptionTemplate implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) TestSubscriptionTemplate(ctx context.Context, eventName string, transformTemplate string, consumer string, strict bool, payload map[string]any) (s1 string, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.TestSubscriptionTemplate")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":               ctx,
				"eventName":         eventName,
				"transformTemplate": transformTemplate,
				"consumer":          consumer,
				"strict":            strict,
				"payload":           payload}, map[string]interface{}{
				"s1":  s1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.TestSubscriptionTemplate(ctx, eventName, transformTemplate, consumer, strict, payload)
}

// UnregisterWebhook implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) UnregisterWebhook(ctx context.Context, webhookID string, consumer string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.UnregisterWebhook")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":       ctx,
				"webhookID": webhookID,
				"consumer":  consumer}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.UnregisterWebhook(ctx, webhookID, consumer)
}

// UpdateEvent implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) UpdateEvent(ctx context.Context, name string, description string, schema map[string]any, metadata map[string]string, active bool, allowBreaking bool) (ep1 *EventTypeSaveResult, err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.UpdateEvent")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":           ctx,
				"name":          name,
				"description":   description,
				"schema":        schema,
				"metadata":      metadata,
				"active":        active,
				"allowBreaking": allowBreaking}, map[string]interface{}{
				"ep1": ep1,
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.UpdateEvent(ctx, name, description, schema, metadata, active, allowBreaking)
}

// UpdateSubscription implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) UpdateSubscription(ctx context.Context, subscriptionID string, consumer string, headers map[string]string, method string, timeout int, transformEnabled bool, transformTemplate string, labelFilters map[string]string, settings SubscriptionTemplateSettings, meta TemplateSaveMeta) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.UpdateSubscription")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":               ctx,
				"subscriptionID":    subscriptionID,
				"consumer":          consumer,
				"headers":           headers,
				"method":            method,
				"timeout":           timeout,
				"transformEnabled":  transformEnabled,
				"transformTemplate": transformTemplate,
				"labelFilters":      labelFilters,
				"settings":          settings,
				"meta":              meta}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.UpdateSubscription(ctx, subscriptionID, consumer, headers, method, timeout, transformEnabled, transformTemplate, labelFilters, settings, meta)
}

// UpdateWebhookConfig implements WebhookServiceInterface
func (_d WebhookServiceInterfaceWithTracing) UpdateWebhookConfig(ctx context.Context, webhookID string, consumer string, events []string, url string, headers map[string]string, active bool, description string, httpConfig *WebhookHTTPConfig, secretHeaders map[string]string, signatureType string, requiresTransform bool, updateMask []string) (err error) {
	ctx, _span := otel.Tracer(_d._instance).Start(ctx, "WebhookServiceInterface.UpdateWebhookConfig")
	defer func() {
		if _d._spanDecorator != nil {
			_d._spanDecorator(_span, map[string]interface{}{
				"ctx":               ctx,
				"webhookID":         webhookID,
				"consumer":          consumer,
				"events":            events,
				"url":               url,
				"headers":           headers,
				"active":            active,
				"description":       description,
				"httpConfig":        httpConfig,
				"secretHeaders":     secretHeaders,
				"signatureType":     signatureType,
				"requiresTransform": requiresTransform,
				"updateMask":        updateMask}, map[string]interface{}{
				"err": err})
		} else if err != nil {
			_span.RecordError(err)
			_span.SetStatus(_codes.Error, err.Error())
			_span.SetAttributes(
				attribute.String("event", "error"),
				attribute.String("message", err.Error()),
			)
		}

		_span.End()
	}()
	return _d.WebhookServiceInterface.UpdateWebhookConfig(ctx, webhookID, consumer, events, url, headers, active, description, httpConfig, secretHeaders, signatureType, requiresTransform, updateMask)
}