go.uber.org/cadence@v1.2.9/internal/common/metrics/service_wrapper.go (about)

     1  // Copyright (c) 2017 Uber Technologies, Inc.
     2  //
     3  // Permission is hereby granted, free of charge, to any person obtaining a copy
     4  // of this software and associated documentation files (the "Software"), to deal
     5  // in the Software without restriction, including without limitation the rights
     6  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     7  // copies of the Software, and to permit persons to whom the Software is
     8  // furnished to do so, subject to the following conditions:
     9  //
    10  // The above copyright notice and this permission notice shall be included in
    11  // all copies or substantial portions of the Software.
    12  //
    13  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    14  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    15  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    16  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    17  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    18  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    19  // THE SOFTWARE.
    20  
    21  package metrics
    22  
    23  import (
    24  	"context"
    25  	"sync"
    26  	"time"
    27  
    28  	"github.com/uber-go/tally"
    29  	"go.uber.org/yarpc"
    30  
    31  	"go.uber.org/cadence/.gen/go/cadence/workflowserviceclient"
    32  	"go.uber.org/cadence/.gen/go/shared"
    33  )
    34  
    35  type (
    36  	workflowServiceMetricsWrapper struct {
    37  		service     workflowserviceclient.Interface
    38  		scope       tally.Scope
    39  		childScopes map[string]tally.Scope
    40  		mutex       sync.Mutex
    41  	}
    42  
    43  	operationScope struct {
    44  		scope     tally.Scope
    45  		startTime time.Time
    46  	}
    47  )
    48  
    49  const (
    50  	scopeNameDeprecateDomain                    = CadenceMetricsPrefix + "DeprecateDomain"
    51  	scopeNameDescribeDomain                     = CadenceMetricsPrefix + "DescribeDomain"
    52  	scopeNameListDomains                        = CadenceMetricsPrefix + "ListDomains"
    53  	scopeNameGetWorkflowExecutionHistory        = CadenceMetricsPrefix + "GetWorkflowExecutionHistory"
    54  	scopeNameGetWorkflowExecutionRawHistory     = CadenceMetricsPrefix + "GetWorkflowExecutionRawHistory"
    55  	scopeNamePollForWorkflowExecutionRawHistory = CadenceMetricsPrefix + "PollForWorkflowExecutionRawHistory"
    56  	scopeNameListClosedWorkflowExecutions       = CadenceMetricsPrefix + "ListClosedWorkflowExecutions"
    57  	scopeNameListOpenWorkflowExecutions         = CadenceMetricsPrefix + "ListOpenWorkflowExecutions"
    58  	scopeNameListWorkflowExecutions             = CadenceMetricsPrefix + "ListWorkflowExecutions"
    59  	scopeNameListArchivedWorkflowExecutions     = CadenceMetricsPrefix + "ListArchviedExecutions"
    60  	scopeNameScanWorkflowExecutions             = CadenceMetricsPrefix + "ScanWorkflowExecutions"
    61  	scopeNameCountWorkflowExecutions            = CadenceMetricsPrefix + "CountWorkflowExecutions"
    62  	scopeNamePollForActivityTask                = CadenceMetricsPrefix + "PollForActivityTask"
    63  	scopeNamePollForDecisionTask                = CadenceMetricsPrefix + "PollForDecisionTask"
    64  	scopeNameRecordActivityTaskHeartbeat        = CadenceMetricsPrefix + "RecordActivityTaskHeartbeat"
    65  	scopeNameRecordActivityTaskHeartbeatByID    = CadenceMetricsPrefix + "RecordActivityTaskHeartbeatByID"
    66  	scopeNameRegisterDomain                     = CadenceMetricsPrefix + "RegisterDomain"
    67  	scopeNameRequestCancelWorkflowExecution     = CadenceMetricsPrefix + "RequestCancelWorkflowExecution"
    68  	scopeNameRespondActivityTaskCanceled        = CadenceMetricsPrefix + "RespondActivityTaskCanceled"
    69  	scopeNameRespondActivityTaskCompleted       = CadenceMetricsPrefix + "RespondActivityTaskCompleted"
    70  	scopeNameRespondActivityTaskFailed          = CadenceMetricsPrefix + "RespondActivityTaskFailed"
    71  	scopeNameRespondActivityTaskCanceledByID    = CadenceMetricsPrefix + "RespondActivityTaskCanceledByID"
    72  	scopeNameRespondActivityTaskCompletedByID   = CadenceMetricsPrefix + "RespondActivityTaskCompletedByID"
    73  	scopeNameRespondActivityTaskFailedByID      = CadenceMetricsPrefix + "RespondActivityTaskFailedByID"
    74  	scopeNameRespondDecisionTaskCompleted       = CadenceMetricsPrefix + "RespondDecisionTaskCompleted"
    75  	scopeNameRespondDecisionTaskFailed          = CadenceMetricsPrefix + "RespondDecisionTaskFailed"
    76  	scopeNameSignalWorkflowExecution            = CadenceMetricsPrefix + "SignalWorkflowExecution"
    77  	scopeNameSignalWithStartWorkflowExecution   = CadenceMetricsPrefix + "SignalWithStartWorkflowExecution"
    78  	scopeNameStartWorkflowExecution             = CadenceMetricsPrefix + "StartWorkflowExecution"
    79  	scopeNameTerminateWorkflowExecution         = CadenceMetricsPrefix + "TerminateWorkflowExecution"
    80  	scopeNameResetWorkflowExecution             = CadenceMetricsPrefix + "ResetWorkflowExecution"
    81  	scopeNameUpdateDomain                       = CadenceMetricsPrefix + "UpdateDomain"
    82  	scopeNameQueryWorkflow                      = CadenceMetricsPrefix + "QueryWorkflow"
    83  	scopeNameDescribeTaskList                   = CadenceMetricsPrefix + "DescribeTaskList"
    84  	scopeNameRespondQueryTaskCompleted          = CadenceMetricsPrefix + "RespondQueryTaskCompleted"
    85  	scopeNameDescribeWorkflowExecution          = CadenceMetricsPrefix + "DescribeWorkflowExecution"
    86  	scopeNameResetStickyTaskList                = CadenceMetricsPrefix + "ResetStickyTaskList"
    87  	scopeNameGetSearchAttributes                = CadenceMetricsPrefix + "GetSearchAttributes"
    88  	scopeNameListTaskListPartitions             = CadenceMetricsPrefix + "ListTaskListPartitions"
    89  	scopeNameGetClusterInfo                     = CadenceMetricsPrefix + "GetClusterInfo"
    90  	scopeRefreshWorkflowTasks                   = CadenceMetricsPrefix + "RefreshWorkflowTasks"
    91  )
    92  
    93  // NewWorkflowServiceWrapper creates a new wrapper to WorkflowService that will emit metrics for each service call.
    94  func NewWorkflowServiceWrapper(service workflowserviceclient.Interface, scope tally.Scope) workflowserviceclient.Interface {
    95  	return &workflowServiceMetricsWrapper{service: service, scope: scope, childScopes: make(map[string]tally.Scope)}
    96  }
    97  
    98  func (w *workflowServiceMetricsWrapper) getScope(scopeName string) tally.Scope {
    99  	w.mutex.Lock()
   100  	scope, ok := w.childScopes[scopeName]
   101  	if ok {
   102  		w.mutex.Unlock()
   103  		return scope
   104  	}
   105  	scope = w.scope.SubScope(scopeName)
   106  	w.childScopes[scopeName] = scope
   107  	w.mutex.Unlock()
   108  	return scope
   109  }
   110  
   111  func (w *workflowServiceMetricsWrapper) getOperationScope(scopeName string) *operationScope {
   112  	scope := w.getScope(scopeName)
   113  	scope.Counter(CadenceRequest).Inc(1)
   114  
   115  	return &operationScope{scope: scope, startTime: time.Now()}
   116  }
   117  
   118  func (s *operationScope) handleError(err error) {
   119  	s.scope.Timer(CadenceLatency).Record(time.Since(s.startTime))
   120  	if err != nil {
   121  		switch err.(type) {
   122  		case *shared.EntityNotExistsError,
   123  			*shared.BadRequestError,
   124  			*shared.DomainAlreadyExistsError,
   125  			*shared.WorkflowExecutionAlreadyStartedError,
   126  			*shared.WorkflowExecutionAlreadyCompletedError,
   127  			*shared.QueryFailedError:
   128  			s.scope.Counter(CadenceInvalidRequest).Inc(1)
   129  		default:
   130  			s.scope.Counter(CadenceError).Inc(1)
   131  		}
   132  	}
   133  }
   134  
   135  func (w *workflowServiceMetricsWrapper) DeprecateDomain(ctx context.Context, request *shared.DeprecateDomainRequest, opts ...yarpc.CallOption) error {
   136  	scope := w.getOperationScope(scopeNameDeprecateDomain)
   137  	err := w.service.DeprecateDomain(ctx, request, opts...)
   138  	scope.handleError(err)
   139  	return err
   140  }
   141  
   142  func (w *workflowServiceMetricsWrapper) ListDomains(ctx context.Context, request *shared.ListDomainsRequest, opts ...yarpc.CallOption) (*shared.ListDomainsResponse, error) {
   143  	scope := w.getOperationScope(scopeNameListDomains)
   144  	result, err := w.service.ListDomains(ctx, request, opts...)
   145  	scope.handleError(err)
   146  	return result, err
   147  }
   148  
   149  func (w *workflowServiceMetricsWrapper) DescribeDomain(ctx context.Context, request *shared.DescribeDomainRequest, opts ...yarpc.CallOption) (*shared.DescribeDomainResponse, error) {
   150  	scope := w.getOperationScope(scopeNameDescribeDomain)
   151  	result, err := w.service.DescribeDomain(ctx, request, opts...)
   152  	scope.handleError(err)
   153  	return result, err
   154  }
   155  
   156  func (w *workflowServiceMetricsWrapper) DescribeWorkflowExecution(ctx context.Context, request *shared.DescribeWorkflowExecutionRequest, opts ...yarpc.CallOption) (*shared.DescribeWorkflowExecutionResponse, error) {
   157  	scope := w.getOperationScope(scopeNameDescribeWorkflowExecution)
   158  	result, err := w.service.DescribeWorkflowExecution(ctx, request, opts...)
   159  	scope.handleError(err)
   160  	return result, err
   161  }
   162  
   163  func (w *workflowServiceMetricsWrapper) GetWorkflowExecutionHistory(ctx context.Context, request *shared.GetWorkflowExecutionHistoryRequest, opts ...yarpc.CallOption) (*shared.GetWorkflowExecutionHistoryResponse, error) {
   164  	scope := w.getOperationScope(scopeNameGetWorkflowExecutionHistory)
   165  	result, err := w.service.GetWorkflowExecutionHistory(ctx, request, opts...)
   166  	scope.handleError(err)
   167  	return result, err
   168  }
   169  
   170  func (w *workflowServiceMetricsWrapper) ListClosedWorkflowExecutions(ctx context.Context, request *shared.ListClosedWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.ListClosedWorkflowExecutionsResponse, error) {
   171  	scope := w.getOperationScope(scopeNameListClosedWorkflowExecutions)
   172  	result, err := w.service.ListClosedWorkflowExecutions(ctx, request, opts...)
   173  	scope.handleError(err)
   174  	return result, err
   175  }
   176  
   177  func (w *workflowServiceMetricsWrapper) ListOpenWorkflowExecutions(ctx context.Context, request *shared.ListOpenWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.ListOpenWorkflowExecutionsResponse, error) {
   178  	scope := w.getOperationScope(scopeNameListOpenWorkflowExecutions)
   179  	result, err := w.service.ListOpenWorkflowExecutions(ctx, request, opts...)
   180  	scope.handleError(err)
   181  	return result, err
   182  }
   183  
   184  func (w *workflowServiceMetricsWrapper) ListWorkflowExecutions(ctx context.Context, request *shared.ListWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.ListWorkflowExecutionsResponse, error) {
   185  	scope := w.getOperationScope(scopeNameListWorkflowExecutions)
   186  	result, err := w.service.ListWorkflowExecutions(ctx, request, opts...)
   187  	scope.handleError(err)
   188  	return result, err
   189  }
   190  
   191  func (w *workflowServiceMetricsWrapper) ListArchivedWorkflowExecutions(ctx context.Context, request *shared.ListArchivedWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.ListArchivedWorkflowExecutionsResponse, error) {
   192  	scope := w.getOperationScope(scopeNameListArchivedWorkflowExecutions)
   193  	result, err := w.service.ListArchivedWorkflowExecutions(ctx, request, opts...)
   194  	scope.handleError(err)
   195  	return result, err
   196  }
   197  
   198  func (w *workflowServiceMetricsWrapper) ScanWorkflowExecutions(ctx context.Context, request *shared.ListWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.ListWorkflowExecutionsResponse, error) {
   199  	scope := w.getOperationScope(scopeNameScanWorkflowExecutions)
   200  	result, err := w.service.ScanWorkflowExecutions(ctx, request, opts...)
   201  	scope.handleError(err)
   202  	return result, err
   203  }
   204  
   205  func (w *workflowServiceMetricsWrapper) CountWorkflowExecutions(ctx context.Context, request *shared.CountWorkflowExecutionsRequest, opts ...yarpc.CallOption) (*shared.CountWorkflowExecutionsResponse, error) {
   206  	scope := w.getOperationScope(scopeNameCountWorkflowExecutions)
   207  	result, err := w.service.CountWorkflowExecutions(ctx, request, opts...)
   208  	scope.handleError(err)
   209  	return result, err
   210  }
   211  
   212  func (w *workflowServiceMetricsWrapper) PollForActivityTask(ctx context.Context, request *shared.PollForActivityTaskRequest, opts ...yarpc.CallOption) (*shared.PollForActivityTaskResponse, error) {
   213  	scope := w.getOperationScope(scopeNamePollForActivityTask)
   214  	result, err := w.service.PollForActivityTask(ctx, request, opts...)
   215  	scope.handleError(err)
   216  	return result, err
   217  }
   218  
   219  func (w *workflowServiceMetricsWrapper) PollForDecisionTask(ctx context.Context, request *shared.PollForDecisionTaskRequest, opts ...yarpc.CallOption) (*shared.PollForDecisionTaskResponse, error) {
   220  	scope := w.getOperationScope(scopeNamePollForDecisionTask)
   221  	result, err := w.service.PollForDecisionTask(ctx, request, opts...)
   222  	scope.handleError(err)
   223  	return result, err
   224  }
   225  
   226  func (w *workflowServiceMetricsWrapper) RecordActivityTaskHeartbeat(ctx context.Context, request *shared.RecordActivityTaskHeartbeatRequest, opts ...yarpc.CallOption) (*shared.RecordActivityTaskHeartbeatResponse, error) {
   227  	scope := w.getOperationScope(scopeNameRecordActivityTaskHeartbeat)
   228  	result, err := w.service.RecordActivityTaskHeartbeat(ctx, request, opts...)
   229  	scope.handleError(err)
   230  	return result, err
   231  }
   232  
   233  func (w *workflowServiceMetricsWrapper) RecordActivityTaskHeartbeatByID(ctx context.Context, request *shared.RecordActivityTaskHeartbeatByIDRequest, opts ...yarpc.CallOption) (*shared.RecordActivityTaskHeartbeatResponse, error) {
   234  	scope := w.getOperationScope(scopeNameRecordActivityTaskHeartbeatByID)
   235  	result, err := w.service.RecordActivityTaskHeartbeatByID(ctx, request, opts...)
   236  	scope.handleError(err)
   237  	return result, err
   238  }
   239  
   240  func (w *workflowServiceMetricsWrapper) RegisterDomain(ctx context.Context, request *shared.RegisterDomainRequest, opts ...yarpc.CallOption) error {
   241  	scope := w.getOperationScope(scopeNameRegisterDomain)
   242  	err := w.service.RegisterDomain(ctx, request, opts...)
   243  	scope.handleError(err)
   244  	return err
   245  }
   246  
   247  func (w *workflowServiceMetricsWrapper) RequestCancelWorkflowExecution(ctx context.Context, request *shared.RequestCancelWorkflowExecutionRequest, opts ...yarpc.CallOption) error {
   248  	scope := w.getOperationScope(scopeNameRequestCancelWorkflowExecution)
   249  	err := w.service.RequestCancelWorkflowExecution(ctx, request, opts...)
   250  	scope.handleError(err)
   251  	return err
   252  }
   253  
   254  func (w *workflowServiceMetricsWrapper) RespondActivityTaskCanceled(ctx context.Context, request *shared.RespondActivityTaskCanceledRequest, opts ...yarpc.CallOption) error {
   255  	scope := w.getOperationScope(scopeNameRespondActivityTaskCanceled)
   256  	err := w.service.RespondActivityTaskCanceled(ctx, request, opts...)
   257  	scope.handleError(err)
   258  	return err
   259  }
   260  
   261  func (w *workflowServiceMetricsWrapper) RespondActivityTaskCompleted(ctx context.Context, request *shared.RespondActivityTaskCompletedRequest, opts ...yarpc.CallOption) error {
   262  	scope := w.getOperationScope(scopeNameRespondActivityTaskCompleted)
   263  	err := w.service.RespondActivityTaskCompleted(ctx, request, opts...)
   264  	scope.handleError(err)
   265  	return err
   266  }
   267  
   268  func (w *workflowServiceMetricsWrapper) RespondActivityTaskFailed(ctx context.Context, request *shared.RespondActivityTaskFailedRequest, opts ...yarpc.CallOption) error {
   269  	scope := w.getOperationScope(scopeNameRespondActivityTaskFailed)
   270  	err := w.service.RespondActivityTaskFailed(ctx, request, opts...)
   271  	scope.handleError(err)
   272  	return err
   273  }
   274  
   275  func (w *workflowServiceMetricsWrapper) RespondActivityTaskCanceledByID(ctx context.Context, request *shared.RespondActivityTaskCanceledByIDRequest, opts ...yarpc.CallOption) error {
   276  	scope := w.getOperationScope(scopeNameRespondActivityTaskCanceledByID)
   277  	err := w.service.RespondActivityTaskCanceledByID(ctx, request, opts...)
   278  	scope.handleError(err)
   279  	return err
   280  }
   281  
   282  func (w *workflowServiceMetricsWrapper) RespondActivityTaskCompletedByID(ctx context.Context, request *shared.RespondActivityTaskCompletedByIDRequest, opts ...yarpc.CallOption) error {
   283  	scope := w.getOperationScope(scopeNameRespondActivityTaskCompletedByID)
   284  	err := w.service.RespondActivityTaskCompletedByID(ctx, request, opts...)
   285  	scope.handleError(err)
   286  	return err
   287  }
   288  
   289  func (w *workflowServiceMetricsWrapper) RespondActivityTaskFailedByID(ctx context.Context, request *shared.RespondActivityTaskFailedByIDRequest, opts ...yarpc.CallOption) error {
   290  	scope := w.getOperationScope(scopeNameRespondActivityTaskFailedByID)
   291  	err := w.service.RespondActivityTaskFailedByID(ctx, request, opts...)
   292  	scope.handleError(err)
   293  	return err
   294  }
   295  
   296  func (w *workflowServiceMetricsWrapper) RespondDecisionTaskCompleted(ctx context.Context, request *shared.RespondDecisionTaskCompletedRequest, opts ...yarpc.CallOption) (*shared.RespondDecisionTaskCompletedResponse, error) {
   297  	scope := w.getOperationScope(scopeNameRespondDecisionTaskCompleted)
   298  	response, err := w.service.RespondDecisionTaskCompleted(ctx, request, opts...)
   299  	scope.handleError(err)
   300  	return response, err
   301  }
   302  
   303  func (w *workflowServiceMetricsWrapper) RespondDecisionTaskFailed(ctx context.Context, request *shared.RespondDecisionTaskFailedRequest, opts ...yarpc.CallOption) error {
   304  	scope := w.getOperationScope(scopeNameRespondDecisionTaskFailed)
   305  	err := w.service.RespondDecisionTaskFailed(ctx, request, opts...)
   306  	scope.handleError(err)
   307  	return err
   308  }
   309  
   310  func (w *workflowServiceMetricsWrapper) SignalWorkflowExecution(ctx context.Context, request *shared.SignalWorkflowExecutionRequest, opts ...yarpc.CallOption) error {
   311  	scope := w.getOperationScope(scopeNameSignalWorkflowExecution)
   312  	err := w.service.SignalWorkflowExecution(ctx, request, opts...)
   313  	scope.handleError(err)
   314  	return err
   315  }
   316  
   317  func (w *workflowServiceMetricsWrapper) SignalWithStartWorkflowExecution(ctx context.Context, request *shared.SignalWithStartWorkflowExecutionRequest, opts ...yarpc.CallOption) (*shared.StartWorkflowExecutionResponse, error) {
   318  	scope := w.getOperationScope(scopeNameSignalWithStartWorkflowExecution)
   319  	result, err := w.service.SignalWithStartWorkflowExecution(ctx, request, opts...)
   320  	scope.handleError(err)
   321  	return result, err
   322  }
   323  
   324  func (w *workflowServiceMetricsWrapper) StartWorkflowExecution(ctx context.Context, request *shared.StartWorkflowExecutionRequest, opts ...yarpc.CallOption) (*shared.StartWorkflowExecutionResponse, error) {
   325  	scope := w.getOperationScope(scopeNameStartWorkflowExecution)
   326  	result, err := w.service.StartWorkflowExecution(ctx, request, opts...)
   327  	scope.handleError(err)
   328  	return result, err
   329  }
   330  
   331  func (w *workflowServiceMetricsWrapper) TerminateWorkflowExecution(ctx context.Context, request *shared.TerminateWorkflowExecutionRequest, opts ...yarpc.CallOption) error {
   332  	scope := w.getOperationScope(scopeNameTerminateWorkflowExecution)
   333  	err := w.service.TerminateWorkflowExecution(ctx, request, opts...)
   334  	scope.handleError(err)
   335  	return err
   336  }
   337  
   338  func (w *workflowServiceMetricsWrapper) ResetWorkflowExecution(ctx context.Context, request *shared.ResetWorkflowExecutionRequest, opts ...yarpc.CallOption) (*shared.ResetWorkflowExecutionResponse, error) {
   339  	scope := w.getOperationScope(scopeNameResetWorkflowExecution)
   340  	result, err := w.service.ResetWorkflowExecution(ctx, request, opts...)
   341  	scope.handleError(err)
   342  	return result, err
   343  }
   344  
   345  func (w *workflowServiceMetricsWrapper) UpdateDomain(ctx context.Context, request *shared.UpdateDomainRequest, opts ...yarpc.CallOption) (*shared.UpdateDomainResponse, error) {
   346  	scope := w.getOperationScope(scopeNameUpdateDomain)
   347  	result, err := w.service.UpdateDomain(ctx, request, opts...)
   348  	scope.handleError(err)
   349  	return result, err
   350  }
   351  
   352  func (w *workflowServiceMetricsWrapper) QueryWorkflow(ctx context.Context, request *shared.QueryWorkflowRequest, opts ...yarpc.CallOption) (*shared.QueryWorkflowResponse, error) {
   353  	scope := w.getOperationScope(scopeNameQueryWorkflow)
   354  	result, err := w.service.QueryWorkflow(ctx, request, opts...)
   355  	scope.handleError(err)
   356  	return result, err
   357  }
   358  
   359  func (w *workflowServiceMetricsWrapper) ResetStickyTaskList(ctx context.Context, request *shared.ResetStickyTaskListRequest, opts ...yarpc.CallOption) (*shared.ResetStickyTaskListResponse, error) {
   360  	scope := w.getOperationScope(scopeNameResetStickyTaskList)
   361  	result, err := w.service.ResetStickyTaskList(ctx, request, opts...)
   362  	scope.handleError(err)
   363  	return result, err
   364  }
   365  
   366  func (w *workflowServiceMetricsWrapper) DescribeTaskList(ctx context.Context, request *shared.DescribeTaskListRequest, opts ...yarpc.CallOption) (*shared.DescribeTaskListResponse, error) {
   367  	scope := w.getOperationScope(scopeNameDescribeTaskList)
   368  	result, err := w.service.DescribeTaskList(ctx, request, opts...)
   369  	scope.handleError(err)
   370  	return result, err
   371  }
   372  
   373  func (w *workflowServiceMetricsWrapper) RespondQueryTaskCompleted(ctx context.Context, request *shared.RespondQueryTaskCompletedRequest, opts ...yarpc.CallOption) error {
   374  	scope := w.getOperationScope(scopeNameRespondQueryTaskCompleted)
   375  	err := w.service.RespondQueryTaskCompleted(ctx, request, opts...)
   376  	scope.handleError(err)
   377  	return err
   378  }
   379  
   380  func (w *workflowServiceMetricsWrapper) GetSearchAttributes(ctx context.Context, opts ...yarpc.CallOption) (*shared.GetSearchAttributesResponse, error) {
   381  	scope := w.getOperationScope(scopeNameGetSearchAttributes)
   382  	result, err := w.service.GetSearchAttributes(ctx, opts...)
   383  	scope.handleError(err)
   384  	return result, err
   385  }
   386  
   387  func (w *workflowServiceMetricsWrapper) ListTaskListPartitions(ctx context.Context, request *shared.ListTaskListPartitionsRequest, opts ...yarpc.CallOption) (*shared.ListTaskListPartitionsResponse, error) {
   388  	scope := w.getOperationScope(scopeNameListTaskListPartitions)
   389  	result, err := w.service.ListTaskListPartitions(ctx, request, opts...)
   390  	scope.handleError(err)
   391  	return result, err
   392  }
   393  
   394  func (w *workflowServiceMetricsWrapper) GetClusterInfo(ctx context.Context, opts ...yarpc.CallOption) (*shared.ClusterInfo, error) {
   395  	scope := w.getOperationScope(scopeNameGetClusterInfo)
   396  	result, err := w.service.GetClusterInfo(ctx, opts...)
   397  	scope.handleError(err)
   398  	return result, err
   399  }
   400  
   401  func (w *workflowServiceMetricsWrapper) GetTaskListsByDomain(ctx context.Context, Request *shared.GetTaskListsByDomainRequest, opts ...yarpc.CallOption) (*shared.GetTaskListsByDomainResponse, error) {
   402  	panic("implement me")
   403  }
   404  
   405  func (w *workflowServiceMetricsWrapper) RefreshWorkflowTasks(ctx context.Context, request *shared.RefreshWorkflowTasksRequest, opts ...yarpc.CallOption) error {
   406  	scope := w.getOperationScope(scopeRefreshWorkflowTasks)
   407  	err := w.service.RefreshWorkflowTasks(ctx, request, opts...)
   408  	scope.handleError(err)
   409  	return err
   410  }
   411  
   412  func (w *workflowServiceMetricsWrapper) RestartWorkflowExecution(ctx context.Context, request *shared.RestartWorkflowExecutionRequest, opts ...yarpc.CallOption) (*shared.RestartWorkflowExecutionResponse, error) {
   413  	scope := w.getOperationScope(scopeRefreshWorkflowTasks)
   414  	resp, err := w.service.RestartWorkflowExecution(ctx, request, opts...)
   415  	scope.handleError(err)
   416  	return resp, err
   417  }