execution_generated.go

// The MIT License (MIT)

// Copyright (c) 2017-2020 Uber Technologies Inc.

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

package metered

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

import (
	"context"

	"github.com/uber/cadence/common/config"
	"github.com/uber/cadence/common/dynamicconfig"
	"github.com/uber/cadence/common/log"
	"github.com/uber/cadence/common/log/tag"
	"github.com/uber/cadence/common/metrics"
	"github.com/uber/cadence/common/persistence"
)

// meteredExecutionManager implements persistence.ExecutionManager interface instrumented with rate limiter.
type meteredExecutionManager struct {
	base
	wrapped persistence.ExecutionManager
}

// NewExecutionManager creates a new instance of ExecutionManager with ratelimiter.
func NewExecutionManager(
	wrapped persistence.ExecutionManager,
	metricClient metrics.Client,
	logger log.Logger,
	cfg *config.Persistence,
	sampleLoggingRate dynamicconfig.IntPropertyFn,
	enableShardIDMetrics dynamicconfig.BoolPropertyFn,
) persistence.ExecutionManager {
	return &meteredExecutionManager{
		wrapped: wrapped,
		base: base{
			metricClient:                  metricClient,
			logger:                        logger.WithTags(tag.ShardID(wrapped.GetShardID())),
			enableLatencyHistogramMetrics: cfg.EnablePersistenceLatencyHistogramMetrics,
			sampleLoggingRate:             sampleLoggingRate,
			enableShardIDMetrics:          enableShardIDMetrics,
		},
	}
}

func (c *meteredExecutionManager) Close() {
	c.wrapped.Close()
	return
}

func (c *meteredExecutionManager) CompleteCrossClusterTask(ctx context.Context, request *persistence.CompleteCrossClusterTaskRequest) (err error) {
	op := func() error {
		err = c.wrapped.CompleteCrossClusterTask(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CompleteCrossClusterTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCompleteCrossClusterTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCompleteCrossClusterTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCompleteCrossClusterTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) CompleteReplicationTask(ctx context.Context, request *persistence.CompleteReplicationTaskRequest) (err error) {
	op := func() error {
		err = c.wrapped.CompleteReplicationTask(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CompleteReplicationTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCompleteReplicationTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCompleteReplicationTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCompleteReplicationTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) CompleteTimerTask(ctx context.Context, request *persistence.CompleteTimerTaskRequest) (err error) {
	op := func() error {
		err = c.wrapped.CompleteTimerTask(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CompleteTimerTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCompleteTimerTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCompleteTimerTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCompleteTimerTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) CompleteTransferTask(ctx context.Context, request *persistence.CompleteTransferTaskRequest) (err error) {
	op := func() error {
		err = c.wrapped.CompleteTransferTask(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CompleteTransferTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCompleteTransferTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCompleteTransferTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCompleteTransferTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) ConflictResolveWorkflowExecution(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest) (cp1 *persistence.ConflictResolveWorkflowExecutionResponse, err error) {
	op := func() error {
		cp1, err = c.wrapped.ConflictResolveWorkflowExecution(ctx, request)
		c.emptyMetric("ExecutionManager.ConflictResolveWorkflowExecution", request, cp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence ConflictResolveWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceConflictResolveWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceConflictResolveWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceConflictResolveWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) CreateFailoverMarkerTasks(ctx context.Context, request *persistence.CreateFailoverMarkersRequest) (err error) {
	op := func() error {
		err = c.wrapped.CreateFailoverMarkerTasks(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CreateFailoverMarkerTasks called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCreateFailoverMarkerTasksScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCreateFailoverMarkerTasksScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCreateFailoverMarkerTasksScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) CreateWorkflowExecution(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest) (cp1 *persistence.CreateWorkflowExecutionResponse, err error) {
	op := func() error {
		cp1, err = c.wrapped.CreateWorkflowExecution(ctx, request)
		c.emptyMetric("ExecutionManager.CreateWorkflowExecution", request, cp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence CreateWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceCreateWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceCreateWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceCreateWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) DeleteCurrentWorkflowExecution(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest) (err error) {
	op := func() error {
		err = c.wrapped.DeleteCurrentWorkflowExecution(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence DeleteCurrentWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceDeleteCurrentWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceDeleteCurrentWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceDeleteCurrentWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) DeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest) (err error) {
	op := func() error {
		err = c.wrapped.DeleteReplicationTaskFromDLQ(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence DeleteReplicationTaskFromDLQ called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceDeleteReplicationTaskFromDLQScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceDeleteReplicationTaskFromDLQScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceDeleteReplicationTaskFromDLQScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) DeleteWorkflowExecution(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest) (err error) {
	op := func() error {
		err = c.wrapped.DeleteWorkflowExecution(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence DeleteWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceDeleteWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceDeleteWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceDeleteWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetCrossClusterTasks(ctx context.Context, request *persistence.GetCrossClusterTasksRequest) (gp1 *persistence.GetCrossClusterTasksResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetCrossClusterTasks(ctx, request)
		c.emptyMetric("ExecutionManager.GetCrossClusterTasks", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetCrossClusterTasks called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetCrossClusterTasksScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetCrossClusterTasksScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetCrossClusterTasksScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetCurrentExecution(ctx context.Context, request *persistence.GetCurrentExecutionRequest) (gp1 *persistence.GetCurrentExecutionResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetCurrentExecution(ctx, request)
		c.emptyMetric("ExecutionManager.GetCurrentExecution", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetCurrentExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetCurrentExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetCurrentExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetCurrentExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetName() (s1 string) {
	return c.wrapped.GetName()
}

func (c *meteredExecutionManager) GetReplicationDLQSize(ctx context.Context, request *persistence.GetReplicationDLQSizeRequest) (gp1 *persistence.GetReplicationDLQSizeResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetReplicationDLQSize(ctx, request)
		c.emptyMetric("ExecutionManager.GetReplicationDLQSize", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetReplicationDLQSize called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetReplicationDLQSizeScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetReplicationDLQSizeScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetReplicationDLQSizeScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetReplicationTasks(ctx context.Context, request *persistence.GetReplicationTasksRequest) (gp1 *persistence.GetReplicationTasksResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetReplicationTasks(ctx, request)
		c.emptyMetric("ExecutionManager.GetReplicationTasks", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetReplicationTasks called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetReplicationTasksScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetReplicationTasksScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetReplicationTasksScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetReplicationTasksFromDLQ(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (gp1 *persistence.GetReplicationTasksFromDLQResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetReplicationTasksFromDLQ(ctx, request)
		c.emptyMetric("ExecutionManager.GetReplicationTasksFromDLQ", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetReplicationTasksFromDLQ called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetReplicationTasksFromDLQScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetReplicationTasksFromDLQScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetReplicationTasksFromDLQScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetShardID() (i1 int) {
	return c.wrapped.GetShardID()
}

func (c *meteredExecutionManager) GetTimerIndexTasks(ctx context.Context, request *persistence.GetTimerIndexTasksRequest) (gp1 *persistence.GetTimerIndexTasksResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetTimerIndexTasks(ctx, request)
		c.emptyMetric("ExecutionManager.GetTimerIndexTasks", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetTimerIndexTasks called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetTimerIndexTasksScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetTimerIndexTasksScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetTimerIndexTasksScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetTransferTasks(ctx context.Context, request *persistence.GetTransferTasksRequest) (gp1 *persistence.GetTransferTasksResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetTransferTasks(ctx, request)
		c.emptyMetric("ExecutionManager.GetTransferTasks", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetTransferTasks called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetTransferTasksScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetTransferTasksScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetTransferTasksScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) GetWorkflowExecution(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (gp1 *persistence.GetWorkflowExecutionResponse, err error) {
	op := func() error {
		gp1, err = c.wrapped.GetWorkflowExecution(ctx, request)
		c.emptyMetric("ExecutionManager.GetWorkflowExecution", request, gp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence GetWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceGetWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceGetWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceGetWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) IsWorkflowExecutionExists(ctx context.Context, request *persistence.IsWorkflowExecutionExistsRequest) (ip1 *persistence.IsWorkflowExecutionExistsResponse, err error) {
	op := func() error {
		ip1, err = c.wrapped.IsWorkflowExecutionExists(ctx, request)
		c.emptyMetric("ExecutionManager.IsWorkflowExecutionExists", request, ip1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence IsWorkflowExecutionExists called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceIsWorkflowExecutionExistsScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceIsWorkflowExecutionExistsScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceIsWorkflowExecutionExistsScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) ListConcreteExecutions(ctx context.Context, request *persistence.ListConcreteExecutionsRequest) (lp1 *persistence.ListConcreteExecutionsResponse, err error) {
	op := func() error {
		lp1, err = c.wrapped.ListConcreteExecutions(ctx, request)
		c.emptyMetric("ExecutionManager.ListConcreteExecutions", request, lp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence ListConcreteExecutions called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceListConcreteExecutionsScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceListConcreteExecutionsScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceListConcreteExecutionsScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) ListCurrentExecutions(ctx context.Context, request *persistence.ListCurrentExecutionsRequest) (lp1 *persistence.ListCurrentExecutionsResponse, err error) {
	op := func() error {
		lp1, err = c.wrapped.ListCurrentExecutions(ctx, request)
		c.emptyMetric("ExecutionManager.ListCurrentExecutions", request, lp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence ListCurrentExecutions called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceListCurrentExecutionsScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceListCurrentExecutionsScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceListCurrentExecutionsScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) PutReplicationTaskToDLQ(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest) (err error) {
	op := func() error {
		err = c.wrapped.PutReplicationTaskToDLQ(ctx, request)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence PutReplicationTaskToDLQ called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistencePutReplicationTaskToDLQScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistencePutReplicationTaskToDLQScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistencePutReplicationTaskToDLQScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) RangeCompleteCrossClusterTask(ctx context.Context, request *persistence.RangeCompleteCrossClusterTaskRequest) (rp1 *persistence.RangeCompleteCrossClusterTaskResponse, err error) {
	op := func() error {
		rp1, err = c.wrapped.RangeCompleteCrossClusterTask(ctx, request)
		c.emptyMetric("ExecutionManager.RangeCompleteCrossClusterTask", request, rp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence RangeCompleteCrossClusterTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceRangeCompleteCrossClusterTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceRangeCompleteCrossClusterTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceRangeCompleteCrossClusterTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) RangeCompleteReplicationTask(ctx context.Context, request *persistence.RangeCompleteReplicationTaskRequest) (rp1 *persistence.RangeCompleteReplicationTaskResponse, err error) {
	op := func() error {
		rp1, err = c.wrapped.RangeCompleteReplicationTask(ctx, request)
		c.emptyMetric("ExecutionManager.RangeCompleteReplicationTask", request, rp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence RangeCompleteReplicationTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceRangeCompleteReplicationTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceRangeCompleteReplicationTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceRangeCompleteReplicationTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) RangeCompleteTimerTask(ctx context.Context, request *persistence.RangeCompleteTimerTaskRequest) (rp1 *persistence.RangeCompleteTimerTaskResponse, err error) {
	op := func() error {
		rp1, err = c.wrapped.RangeCompleteTimerTask(ctx, request)
		c.emptyMetric("ExecutionManager.RangeCompleteTimerTask", request, rp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence RangeCompleteTimerTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceRangeCompleteTimerTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceRangeCompleteTimerTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceRangeCompleteTimerTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) RangeCompleteTransferTask(ctx context.Context, request *persistence.RangeCompleteTransferTaskRequest) (rp1 *persistence.RangeCompleteTransferTaskResponse, err error) {
	op := func() error {
		rp1, err = c.wrapped.RangeCompleteTransferTask(ctx, request)
		c.emptyMetric("ExecutionManager.RangeCompleteTransferTask", request, rp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence RangeCompleteTransferTask called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceRangeCompleteTransferTaskScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceRangeCompleteTransferTaskScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceRangeCompleteTransferTaskScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest) (rp1 *persistence.RangeDeleteReplicationTaskFromDLQResponse, err error) {
	op := func() error {
		rp1, err = c.wrapped.RangeDeleteReplicationTaskFromDLQ(ctx, request)
		c.emptyMetric("ExecutionManager.RangeDeleteReplicationTaskFromDLQ", request, rp1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence RangeDeleteReplicationTaskFromDLQ called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceRangeDeleteReplicationTaskFromDLQScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceRangeDeleteReplicationTaskFromDLQScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceRangeDeleteReplicationTaskFromDLQScope, op, getCustomMetricTags(request)...)

	return
}

func (c *meteredExecutionManager) UpdateWorkflowExecution(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest) (up1 *persistence.UpdateWorkflowExecutionResponse, err error) {
	op := func() error {
		up1, err = c.wrapped.UpdateWorkflowExecution(ctx, request)
		c.emptyMetric("ExecutionManager.UpdateWorkflowExecution", request, up1, err)
		return err
	}

	if domainName, hasDomainName := getDomainNameFromRequest(request); hasDomainName {
		logTags := append([]tag.Tag{tag.WorkflowDomainName(domainName)}, getCustomLogTags(request)...)
		c.logger.SampleInfo("Persistence UpdateWorkflowExecution called", c.sampleLoggingRate(), logTags...)
		if c.enableShardIDMetrics() {
			err = c.callWithDomainAndShardScope(metrics.PersistenceUpdateWorkflowExecutionScope, op, metrics.DomainTag(domainName),
				metrics.ShardIDTag(c.GetShardID()))
		} else {
			err = c.call(metrics.PersistenceUpdateWorkflowExecutionScope, op, metrics.DomainTag(domainName))
		}
		return
	}

	err = c.call(metrics.PersistenceUpdateWorkflowExecutionScope, op, getCustomMetricTags(request)...)

	return
}