namespace_not_found

go.temporal.io/server/service/history/configs/config.go 392 covered LOC · 1 range

  445
  
  	dc *dynamicconfig.Collection,
  
  446
  
  	numberOfShards int32,
  
  447
  >
  ) *Config {
  
config.go

  448
  >
  	cfg := &Config{
  
  449
  >
  		NumberOfShards: numberOfShards,
  
  450
  >
  
  451
  >
  		EnableReplicationStream:                       dynamicconfig.EnableReplicationStream.Get(dc),
  
  452
  >
  		EmitReplicationLifecycleEvents:                dynamicconfig.EmitReplicationLifecycleEvents.Get(dc),
  
  453
  >
  		EnableCloseInboundReplicationStreamOnShutdown: dynamicconfig.EnableCloseInboundReplicationStreamOnShutdown.Get(dc),
  
  454
  >
  		EnableSeparateReplicationEnableFlag:           dynamicconfig.EnableSeparateReplicationEnableFlag.Get(dc),
  
  455
  >
  		HistoryReplicationDLQV2:                       dynamicconfig.EnableHistoryReplicationDLQV2.Get(dc),
  
  456
  >
  
  457
  >
  		RPS:                                  dynamicconfig.HistoryRPS.Get(dc),
  
  458
  >
  		NamespaceRPS:                         dynamicconfig.HistoryNamespaceRPS.Get(dc),
  
  459
  >
  		OperatorRPSRatio:                     dynamicconfig.OperatorRPSRatio.Get(dc),
  
  460
  >
  		MaxIDLengthLimit:                     dynamicconfig.MaxIDLengthLimit.Get(dc),
  
  461
  >
  		PersistenceMaxQPS:                    dynamicconfig.HistoryPersistenceMaxQPS.Get(dc),
  
  462
  >
  		PersistenceGlobalMaxQPS:              dynamicconfig.HistoryPersistenceGlobalMaxQPS.Get(dc),
  
  463
  >
  		PersistenceNamespaceMaxQPS:           dynamicconfig.HistoryPersistenceNamespaceMaxQPS.Get(dc),
  
  464
  >
  		PersistenceGlobalNamespaceMaxQPS:     dynamicconfig.HistoryPersistenceGlobalNamespaceMaxQPS.Get(dc),
  
  465
  >
  		PersistencePerShardNamespaceMaxQPS:   dynamicconfig.HistoryPersistencePerShardNamespaceMaxQPS.Get(dc),
  
  466
  >
  		PersistenceDynamicRateLimitingParams: dynamicconfig.HistoryPersistenceDynamicRateLimitingParams.Get(dc),
  
  467
  >
  		PersistenceQPSBurstRatio:             dynamicconfig.PersistenceQPSBurstRatio.Get(dc),
  
  468
  >
  		AlignMembershipChange:                dynamicconfig.HistoryAlignMembershipChange.Get(dc),
  
  469
  >
  		ShutdownDrainDuration:                dynamicconfig.HistoryShutdownDrainDuration.Get(dc),
  
  470
  >
  		StartupMembershipJoinDelay:           dynamicconfig.HistoryStartupMembershipJoinDelay.Get(dc),
  
  471
  >
  		AllowResetWithPendingChildren:        dynamicconfig.AllowResetWithPendingChildren.Get(dc),
  
  472
  >
  		MaxAutoResetPoints:                   dynamicconfig.HistoryMaxAutoResetPoints.Get(dc),
  
  473
  >
  		DefaultWorkflowTaskTimeout:           dynamicconfig.DefaultWorkflowTaskTimeout.Get(dc),
  
  474
  >
  
  475
  >
  		MaxLocalParentWorkflowVerificationDuration: dynamicconfig.MaxLocalParentWorkflowVerificationDuration.Get(dc),
  
  476
  >
  
  477
  >
  		VisibilityPersistenceMaxReadQPS:         dynamicconfig.VisibilityPersistenceMaxReadQPS.Get(dc),
  
  478
  >
  		VisibilityPersistenceMaxWriteQPS:        dynamicconfig.VisibilityPersistenceMaxWriteQPS.Get(dc),
  
  479
  >
  		VisibilityPersistenceSlowQueryThreshold: dynamicconfig.VisibilityPersistenceSlowQueryThreshold.Get(dc),
  
  480
  >
  		EnableReadFromSecondaryVisibility:       dynamicconfig.EnableReadFromSecondaryVisibility.Get(dc),
  
  481
  >
  		VisibilityEnableShadowReadMode:          dynamicconfig.VisibilityEnableShadowReadMode.Get(dc),
  
  482
  >
  		SecondaryVisibilityWritingMode:          dynamicconfig.SecondaryVisibilityWritingMode.Get(dc),
  
  483
  >
  		VisibilityDisableOrderByClause:          dynamicconfig.VisibilityDisableOrderByClause.Get(dc),
  
  484
  >
  		VisibilityEnableManualPagination:        dynamicconfig.VisibilityEnableManualPagination.Get(dc),
  
  485
  >
  		VisibilityEnableUnifiedQueryConverter:   dynamicconfig.VisibilityEnableUnifiedQueryConverter.Get(dc),
  
  486
  >
  		VisibilityAllowList:                     dynamicconfig.VisibilityAllowList.Get(dc),
  
  487
  >
  		SuppressErrorSetSystemSearchAttribute:   dynamicconfig.SuppressErrorSetSystemSearchAttribute.Get(dc),
  
  488
  >
  
  489
  >
  		EmitShardLagLog:       dynamicconfig.EmitShardLagLog.Get(dc),
  
  490
  >
  		EnableDataLossMetrics: dynamicconfig.EnableDataLossMetrics.Get(dc),
  
  491
  >
  		// HistoryCacheLimitSizeBased should not change during runtime.
  
  492
  >
  		HistoryCacheLimitSizeBased:            dynamicconfig.HistoryCacheSizeBasedLimit.Get(dc)(),
  
  493
  >
  		HistoryHostLevelCacheMaxSize:          dynamicconfig.HistoryCacheHostLevelMaxSize.Get(dc),
  
  494
  >
  		HistoryHostLevelCacheMaxSizeBytes:     dynamicconfig.HistoryCacheHostLevelMaxSizeBytes.Get(dc),
  
  495
  >
  		HistoryCacheTTL:                       dynamicconfig.HistoryCacheTTL.Get(dc),
  
  496
  >
  		HistoryCacheNonUserContextLockTimeout: dynamicconfig.HistoryCacheNonUserContextLockTimeout.Get(dc),
  
  497
  >
  		HistoryCacheBackgroundEvict:           dynamicconfig.HistoryCacheBackgroundEvict.Get(dc),
  
  498
  >
  		EnableWorkflowExecutionTimeoutTimer:   dynamicconfig.EnableWorkflowExecutionTimeoutTimer.Get(dc),
  
  499
  >
  		EnableUpdateWorkflowModeIgnoreCurrent: dynamicconfig.EnableUpdateWorkflowModeIgnoreCurrent.Get(dc),
  
  500
  >
  		EnableTransitionHistory:               dynamicconfig.EnableTransitionHistory.Get(dc),
  
  501
  >
  		MaxCallbacksPerWorkflow:               dynamicconfig.MaxCallbacksPerWorkflow.Get(dc),
  
  502
  >
  		MaxCallbacksPerExecution:              callback.MaxPerExecution.Get(dc),
  
  503
  >
  		MaxCallbacksPerUpdateID:               dynamicconfig.MaxCallbacksPerUpdateID.Get(dc),
  
  504
  >
  		EnableChasm:                           dynamicconfig.EnableChasm.Get(dc),
  
  505
  >
  		EnableChasmNexusWorkflowOperations:    nexusoperation.EnableChasmWorkflowOperations.Get(dc),
  
  506
  >
  		ChasmMaxInMemoryPureTasks:             dynamicconfig.ChasmMaxInMemoryPureTasks.Get(dc),
  
  507
  >
  
  508
  >
  		EnableCHASMSchedulerCreation:  dynamicconfig.EnableCHASMSchedulerCreation.Get(dc),
  
  509
  >
  		EnableCHASMSchedulerMigration: dynamicconfig.EnableCHASMSchedulerMigration.Get(dc),
  
  510
  >
  
  511
  >
  		EnableCHASMCallbacks:          dynamicconfig.EnableCHASMCallbacks.Get(dc),
  
  512
  >
  		EnableCHASMSignalBacklinks:    dynamicconfig.EnableCHASMSignalBacklinks.Get(dc),
  
  513
  >
  		ExternalPayloadsEnabled:       dynamicconfig.ExternalPayloadsEnabled.Get(dc),
  
  514
  >
  		EnableWorkflowUpdateCallbacks: dynamicconfig.EnableWorkflowUpdateCallbacks.Get(dc),
  
  515
  >
  
  516
  >
  		EventsShardLevelCacheMaxSizeBytes: dynamicconfig.EventsCacheMaxSizeBytes.Get(dc),          // 512KB
  
  517
  >
  		EventsHostLevelCacheMaxSizeBytes:  dynamicconfig.EventsHostLevelCacheMaxSizeBytes.Get(dc), // 256MB
  
  518
  >
  		EventsCacheTTL:                    dynamicconfig.EventsCacheTTL.Get(dc),
  
  519
  >
  		EnableHostLevelEventsCache:        dynamicconfig.EnableHostLevelEventsCache.Get(dc),
  
  520
  >
  
  521
  >
  		RangeSizeBits: 20, // 20 bits for sequencer, 2^20 sequence number for any range
  
  522
  >
  
  523
  >
  		AcquireShardInterval:         dynamicconfig.AcquireShardInterval.Get(dc),
  
  524
  >
  		AcquireShardConcurrency:      dynamicconfig.AcquireShardConcurrency.Get(dc),
  
  525
  >
  		ShardIOConcurrency:           dynamicconfig.ShardIOConcurrency.Get(dc),
  
  526
  >
  		ShardIOTimeout:               dynamicconfig.ShardIOTimeout.Get(dc),
  
  527
  >
  		ShardLingerOwnershipCheckQPS: dynamicconfig.ShardLingerOwnershipCheckQPS.Get(dc),
  
  528
  >
  		ShardLingerTimeLimit:         dynamicconfig.ShardLingerTimeLimit.Get(dc),
  
  529
  >
  		ShardFinalizerTimeout:        dynamicconfig.ShardFinalizerTimeout.Get(dc),
  
  530
  >
  
  531
  >
  		HistoryClientOwnershipCachingEnabled: dynamicconfig.HistoryClientOwnershipCachingEnabled.Get(dc),
  
  532
  >
  
  533
  >
  		StandbyClusterDelay:                  dynamicconfig.StandbyClusterDelay.Get(dc),
  
  534
  >
  		StandbyTaskMissingEventsResendDelay:  dynamicconfig.StandbyTaskMissingEventsResendDelay.Get(dc),
  
  535
  >
  		StandbyTaskMissingEventsDiscardDelay: dynamicconfig.StandbyTaskMissingEventsDiscardDelay.Get(dc),
  
  536
  >
  		ChasmStandbyTaskDiscardDelay:         dynamicconfig.ChasmStandbyTaskDiscardDelay.Get(dc),
  
  537
  >
  
  538
  >
  		QueuePendingTaskCriticalCount:      dynamicconfig.QueuePendingTaskCriticalCount.Get(dc),
  
  539
  >
  		QueueReaderStuckCriticalAttempts:   dynamicconfig.QueueReaderStuckCriticalAttempts.Get(dc),
  
  540
  >
  		QueueCriticalSlicesCount:           dynamicconfig.QueueCriticalSlicesCount.Get(dc),
  
  541
  >
  		QueuePendingTaskMaxCount:           dynamicconfig.QueuePendingTaskMaxCount.Get(dc),
  
  542
  >
  		QueueMaxPredicateSize:              dynamicconfig.QueueMaxPredicateSize.Get(dc),
  
  543
  >
  		QueueShrinkPredicateMaxPendingKeys: dynamicconfig.QueueShrinkPredicateMaxPendingKeys.Get(dc),
  
  544
  >
  		QueueMoveGroupTaskCountBase:        dynamicconfig.QueueMoveGroupTaskCountBase.Get(dc),
  
  545
  >
  		QueueMoveGroupTaskCountMultiplier:  dynamicconfig.QueueMoveGroupTaskCountMultiplier.Get(dc),
  
  546
  >
  
  547
  >
  		TaskDLQEnabled:                 dynamicconfig.HistoryTaskDLQEnabled.Get(dc),
  
  548
  >
  		TaskDLQUnexpectedErrorAttempts: dynamicconfig.HistoryTaskDLQUnexpectedErrorAttempts.Get(dc),
  
  549
  >
  		TaskDLQInternalErrors:          dynamicconfig.HistoryTaskDLQInternalErrors.Get(dc),
  
  550
  >
  		TaskDLQErrorPattern:            dynamicconfig.HistoryTaskDLQErrorPattern.Get(dc),
  
  551
  >
  
  552
  >
  		TaskSchedulerEnableRateLimiter:                       dynamicconfig.TaskSchedulerEnableRateLimiter.Get(dc),
  
  553
  >
  		TaskSchedulerEnableRateLimiterShadowMode:             dynamicconfig.TaskSchedulerEnableRateLimiterShadowMode.Get(dc),
  
  554
  >
  		TaskSchedulerRateLimiterStartupDelay:                 dynamicconfig.TaskSchedulerRateLimiterStartupDelay.Get(dc),
  
  555
  >
  		TaskSchedulerGlobalMaxQPS:                            dynamicconfig.TaskSchedulerGlobalMaxQPS.Get(dc),
  
  556
  >
  		TaskSchedulerMaxQPS:                                  dynamicconfig.TaskSchedulerMaxQPS.Get(dc),
  
  557
  >
  		TaskSchedulerNamespaceMaxQPS:                         dynamicconfig.TaskSchedulerNamespaceMaxQPS.Get(dc),
  
  558
  >
  		TaskSchedulerGlobalNamespaceMaxQPS:                   dynamicconfig.TaskSchedulerGlobalNamespaceMaxQPS.Get(dc),
  
  559
  >
  		TaskSchedulerInactiveChannelDeletionDelay:            dynamicconfig.TaskSchedulerInactiveChannelDeletionDelay.Get(dc),
  
  560
  >
  		TaskSchedulerEnableExecutionQueueScheduler:           dynamicconfig.TaskSchedulerEnableExecutionQueueScheduler.Get(dc),
  
  561
  >
  		TaskSchedulerExecutionQueueSchedulerMaxQueues:        dynamicconfig.TaskSchedulerExecutionQueueSchedulerMaxQueues.Get(dc),
  
  562
  >
  		TaskSchedulerExecutionQueueSchedulerQueueTTL:         dynamicconfig.TaskSchedulerExecutionQueueSchedulerQueueTTL.Get(dc),
  
  563
  >
  		TaskSchedulerExecutionQueueSchedulerQueueConcurrency: dynamicconfig.TaskSchedulerExecutionQueueSchedulerQueueConcurrency.Get(dc),
  
  564
  >
  
  565
  >
  		TimerTaskBatchSize:                               dynamicconfig.TimerTaskBatchSize.Get(dc),
  
  566
  >
  		TimerProcessorSchedulerWorkerCount:               dynamicconfig.TimerProcessorSchedulerWorkerCount.Subscribe(dc),
  
  567
  >
  		TimerProcessorSchedulerActiveRoundRobinWeights:   dynamicconfig.TimerProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),
  
  568
  >
  		TimerProcessorSchedulerStandbyRoundRobinWeights:  dynamicconfig.TimerProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),
  
  569
  >
  		TimerProcessorUpdateAckInterval:                  dynamicconfig.TimerProcessorUpdateAckInterval.Get(dc),
  
  570
  >
  		TimerProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.TimerProcessorUpdateAckIntervalJitterCoefficient.Get(dc),
  
  571
  >
  		TimerProcessorMaxPollRPS:                         dynamicconfig.TimerProcessorMaxPollRPS.Get(dc),
  
  572
  >
  		TimerProcessorMaxPollHostRPS:                     dynamicconfig.TimerProcessorMaxPollHostRPS.Get(dc),
  
  573
  >
  		TimerProcessorMaxPollInterval:                    dynamicconfig.TimerProcessorMaxPollInterval.Get(dc),
  
  574
  >
  		TimerProcessorMaxPollIntervalJitterCoefficient:   dynamicconfig.TimerProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  575
  >
  		TimerProcessorPollBackoffInterval:                dynamicconfig.TimerProcessorPollBackoffInterval.Get(dc),
  
  576
  >
  		TimerProcessorMaxTimeShift:                       dynamicconfig.TimerProcessorMaxTimeShift.Get(dc),
  
  577
  >
  		TransferQueueMaxReaderCount:                      dynamicconfig.TransferQueueMaxReaderCount.Get(dc),
  
  578
  >
  		RetentionTimerJitterDuration:                     dynamicconfig.RetentionTimerJitterDuration.Get(dc),
  
  579
  >
  
  580
  >
  		MemoryTimerProcessorSchedulerWorkerCount: dynamicconfig.MemoryTimerProcessorSchedulerWorkerCount.Subscribe(dc),
  
  581
  >
  
  582
  >
  		TransferTaskBatchSize:                               dynamicconfig.TransferTaskBatchSize.Get(dc),
  
  583
  >
  		TransferProcessorSchedulerWorkerCount:               dynamicconfig.TransferProcessorSchedulerWorkerCount.Subscribe(dc),
  
  584
  >
  		TransferProcessorSchedulerActiveRoundRobinWeights:   dynamicconfig.TransferProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),
  
  585
  >
  		TransferProcessorSchedulerStandbyRoundRobinWeights:  dynamicconfig.TransferProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),
  
  586
  >
  		TransferProcessorMaxPollRPS:                         dynamicconfig.TransferProcessorMaxPollRPS.Get(dc),
  
  587
  >
  		TransferProcessorMaxPollHostRPS:                     dynamicconfig.TransferProcessorMaxPollHostRPS.Get(dc),
  
  588
  >
  		TransferProcessorMaxPollInterval:                    dynamicconfig.TransferProcessorMaxPollInterval.Get(dc),
  
  589
  >
  		TransferProcessorMaxPollIntervalJitterCoefficient:   dynamicconfig.TransferProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  590
  >
  		TransferProcessorUpdateAckInterval:                  dynamicconfig.TransferProcessorUpdateAckInterval.Get(dc),
  
  591
  >
  		TransferProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.TransferProcessorUpdateAckIntervalJitterCoefficient.Get(dc),
  
  592
  >
  		TransferProcessorPollBackoffInterval:                dynamicconfig.TransferProcessorPollBackoffInterval.Get(dc),
  
  593
  >
  		TransferProcessorEnsureCloseBeforeDelete:            dynamicconfig.TransferProcessorEnsureCloseBeforeDelete.Get(dc),
  
  594
  >
  		TimerQueueMaxReaderCount:                            dynamicconfig.TimerQueueMaxReaderCount.Get(dc),
  
  595
  >
  
  596
  >
  		OutboundTaskBatchSize:                               dynamicconfig.OutboundTaskBatchSize.Get(dc),
  
  597
  >
  		OutboundProcessorMaxPollRPS:                         dynamicconfig.OutboundProcessorMaxPollRPS.Get(dc),
  
  598
  >
  		OutboundProcessorMaxPollHostRPS:                     dynamicconfig.OutboundProcessorMaxPollHostRPS.Get(dc),
  
  599
  >
  		OutboundProcessorMaxPollInterval:                    dynamicconfig.OutboundProcessorMaxPollInterval.Get(dc),
  
  600
  >
  		OutboundProcessorMaxPollIntervalJitterCoefficient:   dynamicconfig.OutboundProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  601
  >
  		OutboundProcessorUpdateAckInterval:                  dynamicconfig.OutboundProcessorUpdateAckInterval.Get(dc),
  
  602
  >
  		OutboundProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.OutboundProcessorUpdateAckIntervalJitterCoefficient.Get(dc),
  
  603
  >
  		OutboundProcessorPollBackoffInterval:                dynamicconfig.OutboundProcessorPollBackoffInterval.Get(dc),
  
  604
  >
  		OutboundQueuePendingTaskCriticalCount:               dynamicconfig.OutboundQueuePendingTaskCriticalCount.Get(dc),
  
  605
  >
  		OutboundQueuePendingTaskMaxCount:                    dynamicconfig.OutboundQueuePendingTaskMaxCount.Get(dc),
  
  606
  >
  		OutboundQueueMaxPredicateSize:                       dynamicconfig.OutboundQueueMaxPredicateSize.Get(dc),
  
  607
  >
  		OutboundQueueMaxReaderCount:                         dynamicconfig.OutboundQueueMaxReaderCount.Get(dc),
  
  608
  >
  		OutboundQueueGroupLimiterBufferSize:                 dynamicconfig.OutboundQueueGroupLimiterBufferSize.Get(dc),
  
  609
  >
  		OutboundQueueGroupLimiterConcurrency:                dynamicconfig.OutboundQueueGroupLimiterConcurrency.Get(dc),
  
  610
  >
  		OutboundQueueHostSchedulerMaxTaskRPS:                dynamicconfig.OutboundQueueHostSchedulerMaxTaskRPS.Get(dc),
  
  611
  >
  		OutboundQueueCircuitBreakerSettings:                 dynamicconfig.OutboundQueueCircuitBreakerSettings.Subscribe(dc),
  
  612
  >
  		OutboundStandbyTaskMissingEventsDestinationDownErr:  dynamicconfig.OutboundStandbyTaskMissingEventsDestinationDownErr.Get(dc),
  
  613
  >
  		OutboundStandbyTaskMissingEventsDiscardDelay:        dynamicconfig.OutboundStandbyTaskMissingEventsDiscardDelay.Get(dc),
  
  614
  >
  
  615
  >
  		ReplicatorProcessorMaxPollInterval:                  dynamicconfig.ReplicatorProcessorMaxPollInterval.Get(dc),
  
  616
  >
  		ReplicatorProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.ReplicatorProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  617
  >
  		ReplicatorProcessorFetchTasksBatchSize:              dynamicconfig.ReplicatorTaskBatchSize.Get(dc),
  
  618
  >
  		ReplicatorProcessorMaxSkipTaskCount:                 dynamicconfig.ReplicatorMaxSkipTaskCount.Get(dc),
  
  619
  >
  		ReplicationTaskProcessorHostQPS:                     dynamicconfig.ReplicationTaskProcessorHostQPS.Get(dc),
  
  620
  >
  		ReplicationTaskProcessorShardQPS:                    dynamicconfig.ReplicationTaskProcessorShardQPS.Get(dc),
  
  621
  >
  		ReplicationEnableDLQMetrics:                         dynamicconfig.ReplicationEnableDLQMetrics.Get(dc),
  
  622
  >
  		ReplicationEnableUpdateWithNewTaskMerge:             dynamicconfig.ReplicationEnableUpdateWithNewTaskMerge.Get(dc),
  
  623
  >
  		ReplicationStreamSyncStatusDuration:                 dynamicconfig.ReplicationStreamSyncStatusDuration.Get(dc),
  
  624
  >
  		ReplicationProcessorSchedulerQueueSize:              dynamicconfig.ReplicationProcessorSchedulerQueueSize.Get(dc),
  
  625
  >
  		ReplicationProcessorSchedulerWorkerCount:            dynamicconfig.ReplicationProcessorSchedulerWorkerCount.Subscribe(dc),
  
  626
  >
  		ReplicationLowPriorityProcessorSchedulerWorkerCount: dynamicconfig.ReplicationLowPriorityProcessorSchedulerWorkerCount.Subscribe(dc),
  
  627
  >
  		ReplicationLowPriorityTaskParallelism:               dynamicconfig.ReplicationLowPriorityTaskParallelism.Get(dc),
  
  628
  >
  		EnableReplicationTaskBatching:                       dynamicconfig.EnableReplicationTaskBatching.Get(dc),
  
  629
  >
  		EnableReplicationTaskTieredProcessing:               dynamicconfig.EnableReplicationTaskTieredProcessing.Get(dc),
  
  630
  >
  		ReplicationStreamSenderHighPriorityQPS:              dynamicconfig.ReplicationStreamSenderHighPriorityQPS.Get(dc),
  
  631
  >
  		ReplicationStreamSenderLowPriorityQPS:               dynamicconfig.ReplicationStreamSenderLowPriorityQPS.Get(dc),
  
  632
  >
  		ReplicationStreamEventLoopRetryMaxAttempts:          dynamicconfig.ReplicationStreamEventLoopRetryMaxAttempts.Get(dc),
  
  633
  >
  		ReplicationReceiverMaxOutstandingTaskCount:          dynamicconfig.ReplicationReceiverMaxOutstandingTaskCount.Get(dc),
  
  634
  >
  		ReplicationReceiverSlowSubmissionLatencyThreshold:   dynamicconfig.ReplicationReceiverSlowSubmissionLatencyThreshold.Get(dc),
  
  635
  >
  		ReplicationReceiverSlowSubmissionWindow:             dynamicconfig.ReplicationReceiverSlowSubmissionWindow.Get(dc),
  
  636
  >
  		EnableReplicationReceiverSlowSubmissionFlowControl:  dynamicconfig.EnableReplicationReceiverSlowSubmissionFlowControl.Get(dc),
  
  637
  >
  		ReplicationResendMaxBatchCount:                      dynamicconfig.ReplicationResendMaxBatchCount.Get(dc),
  
  638
  >
  		ReplicationProgressCacheMaxSize:                     dynamicconfig.ReplicationProgressCacheMaxSize.Get(dc),
  
  639
  >
  		ReplicationProgressCacheTTL:                         dynamicconfig.ReplicationProgressCacheTTL.Get(dc),
  
  640
  >
  		ReplicationEnableRateLimit:                          dynamicconfig.ReplicationEnableRateLimit.Get(dc),
  
  641
  >
  		ReplicationEnableRateLimitShadowMode:                dynamicconfig.ReplicationEnableRateLimitShadowMode.Get(dc),
  
  642
  >
  		ReplicationStreamSendEmptyTaskDuration:              dynamicconfig.ReplicationStreamSendEmptyTaskDuration.Get(dc),
  
  643
  >
  		ReplicationStreamReceiverLivenessMultiplier:         dynamicconfig.ReplicationStreamReceiverLivenessMultiplier.Get(dc),
  
  644
  >
  		ReplicationStreamSenderLivenessMultiplier:           dynamicconfig.ReplicationStreamSenderLivenessMultiplier.Get(dc),
  
  645
  >
  		EnableHistoryReplicationRateLimiter:                 dynamicconfig.EnableHistoryReplicationRateLimiter.Get(dc),
  
  646
  >
  
  647
  >
  		MaximumBufferedEventsBatch:       dynamicconfig.MaximumBufferedEventsBatch.Get(dc),
  
  648
  >
  		MaximumBufferedEventsSizeInBytes: dynamicconfig.MaximumBufferedEventsSizeInBytes.Get(dc),
  
  649
  >
  		MaximumSignalsPerExecution:       dynamicconfig.MaximumSignalsPerExecution.Get(dc),
  
  650
  >
  		MaximumEventBatchSizeInBytes:     dynamicconfig.MaximumEventBatchSizeInBytes.Get(dc),
  
  651
  >
  		ShardUpdateMinInterval:           dynamicconfig.ShardUpdateMinInterval.Get(dc),
  
  652
  >
  		ShardFirstUpdateInterval:         dynamicconfig.ShardFirstUpdateInterval.Get(dc),
  
  653
  >
  		ShardUpdateMinTasksCompleted:     dynamicconfig.ShardUpdateMinTasksCompleted.Get(dc),
  
  654
  >
  		ShardSyncMinInterval:             dynamicconfig.ShardSyncMinInterval.Get(dc),
  
  655
  >
  		ShardSyncTimerJitterCoefficient:  dynamicconfig.TransferProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  656
  >
  
  657
  >
  		// history client: client/history/client.go set the client timeout 30s
  
  658
  >
  		// TODO: Return this value to the client: go.temporal.io/server/issues/294
  
  659
  >
  		LongPollExpirationInterval:          dynamicconfig.HistoryLongPollExpirationInterval.Get(dc),
  
  660
  >
  		EnableParentClosePolicy:             dynamicconfig.EnableParentClosePolicy.Get(dc),
  
  661
  >
  		NumParentClosePolicySystemWorkflows: dynamicconfig.NumParentClosePolicySystemWorkflows.Get(dc),
  
  662
  >
  		EnableParentClosePolicyWorker:       dynamicconfig.EnableParentClosePolicyWorker.Get(dc),
  
  663
  >
  		ParentClosePolicyThreshold:          dynamicconfig.ParentClosePolicyThreshold.Get(dc),
  
  664
  >
  
  665
  >
  		BlobSizeLimitError:                        dynamicconfig.BlobSizeLimitError.Get(dc),
  
  666
  >
  		BlobSizeLimitWarn:                         dynamicconfig.BlobSizeLimitWarn.Get(dc),
  
  667
  >
  		MemoSizeLimitError:                        dynamicconfig.MemoSizeLimitError.Get(dc),
  
  668
  >
  		MemoSizeLimitWarn:                         dynamicconfig.MemoSizeLimitWarn.Get(dc),
  
  669
  >
  		NumPendingChildExecutionsLimit:            dynamicconfig.NumPendingChildExecutionsLimitError.Get(dc),
  
  670
  >
  		NumPendingActivitiesLimit:                 dynamicconfig.NumPendingActivitiesLimitError.Get(dc),
  
  671
  >
  		NumPendingSignalsLimit:                    dynamicconfig.NumPendingSignalsLimitError.Get(dc),
  
  672
  >
  		NumPendingCancelsRequestLimit:             dynamicconfig.NumPendingCancelRequestsLimitError.Get(dc),
  
  673
  >
  		HistorySizeLimitError:                     dynamicconfig.HistorySizeLimitError.Get(dc),
  
  674
  >
  		HistorySizeLimitWarn:                      dynamicconfig.HistorySizeLimitWarn.Get(dc),
  
  675
  >
  		HistorySizeSuggestContinueAsNew:           dynamicconfig.HistorySizeSuggestContinueAsNew.Get(dc),
  
  676
  >
  		HistoryCountLimitError:                    dynamicconfig.HistoryCountLimitError.Get(dc),
  
  677
  >
  		HistoryCountLimitWarn:                     dynamicconfig.HistoryCountLimitWarn.Get(dc),
  
  678
  >
  		HistoryCountSuggestContinueAsNew:          dynamicconfig.HistoryCountSuggestContinueAsNew.Get(dc),
  
  679
  >
  		HistoryMaxPageSize:                        dynamicconfig.HistoryMaxPageSize.Get(dc),
  
  680
  >
  		MutableStateActivityFailureSizeLimitError: dynamicconfig.MutableStateActivityFailureSizeLimitError.Get(dc),
  
  681
  >
  		MutableStateActivityFailureSizeLimitWarn:  dynamicconfig.MutableStateActivityFailureSizeLimitWarn.Get(dc),
  
  682
  >
  		MutableStateSizeLimitError:                dynamicconfig.MutableStateSizeLimitError.Get(dc),
  
  683
  >
  		MutableStateSizeLimitWarn:                 dynamicconfig.MutableStateSizeLimitWarn.Get(dc),
  
  684
  >
  		MutableStateTombstoneCountLimit:           dynamicconfig.MutableStateTombstoneCountLimit.Get(dc),
  
  685
  >
  
  686
  >
  		ThrottledLogRPS:   dynamicconfig.HistoryThrottledLogRPS.Get(dc),
  
  687
  >
  		EnableStickyQuery: dynamicconfig.EnableStickyQuery.Get(dc),
  
  688
  >
  
  689
  >
  		DefaultActivityRetryPolicy:                       dynamicconfig.DefaultActivityRetryPolicy.Get(dc),
  
  690
  >
  		DefaultWorkflowRetryPolicy:                       dynamicconfig.DefaultWorkflowRetryPolicy.Get(dc),
  
  691
  >
  		WorkflowTaskHeartbeatTimeout:                     dynamicconfig.WorkflowTaskHeartbeatTimeout.Get(dc),
  
  692
  >
  		WorkflowTaskCriticalAttempts:                     dynamicconfig.WorkflowTaskCriticalAttempts.Get(dc),
  
  693
  >
  		WorkflowTaskRetryMaxInterval:                     dynamicconfig.WorkflowTaskRetryMaxInterval.Get(dc),
  
  694
  >
  		EnableWorkflowTaskStampIncrementOnFailure:        dynamicconfig.EnableWorkflowTaskStampIncrementOnFailure.Get(dc),
  
  695
  >
  		DiscardSpeculativeWorkflowTaskMaximumEventsCount: dynamicconfig.DiscardSpeculativeWorkflowTaskMaximumEventsCount.Get(dc),
  
  696
  >
  		EnableDropRepeatedWorkflowTaskFailures:           dynamicconfig.EnableDropRepeatedWorkflowTaskFailures.Get(dc),
  
  697
  >
  		SendTransientOrSpeculativeWorkflowTaskEvents:     dynamicconfig.SendTransientOrSpeculativeWorkflowTaskEvents.Get(dc),
  
  698
  >
  
  699
  >
  		ReplicationTaskApplyTimeout:                  dynamicconfig.ReplicationTaskApplyTimeout.Get(dc),
  
  700
  >
  		ReplicationTaskFetcherParallelism:            dynamicconfig.ReplicationTaskFetcherParallelism.Get(dc),
  
  701
  >
  		ReplicationTaskFetcherAggregationInterval:    dynamicconfig.ReplicationTaskFetcherAggregationInterval.Get(dc),
  
  702
  >
  		ReplicationTaskFetcherTimerJitterCoefficient: dynamicconfig.ReplicationTaskFetcherTimerJitterCoefficient.Get(dc),
  
  703
  >
  		ReplicationTaskFetcherErrorRetryWait:         dynamicconfig.ReplicationTaskFetcherErrorRetryWait.Get(dc),
  
  704
  >
  
  705
  >
  		ReplicationTaskProcessorErrorRetryWait:               dynamicconfig.ReplicationTaskProcessorErrorRetryWait.Get(dc),
  
  706
  >
  		ReplicationTaskProcessorErrorRetryBackoffCoefficient: dynamicconfig.ReplicationTaskProcessorErrorRetryBackoffCoefficient.Get(dc),
  
  707
  >
  		ReplicationTaskProcessorErrorRetryMaxInterval:        dynamicconfig.ReplicationTaskProcessorErrorRetryMaxInterval.Get(dc),
  
  708
  >
  		ReplicationTaskProcessorErrorRetryMaxAttempts:        dynamicconfig.ReplicationTaskProcessorErrorRetryMaxAttempts.Get(dc),
  
  709
  >
  		ReplicationTaskProcessorErrorRetryExpiration:         dynamicconfig.ReplicationTaskProcessorErrorRetryExpiration.Get(dc),
  
  710
  >
  		ReplicationTaskProcessorNoTaskRetryWait:              dynamicconfig.ReplicationTaskProcessorNoTaskInitialWait.Get(dc),
  
  711
  >
  		ReplicationTaskProcessorCleanupInterval:              dynamicconfig.ReplicationTaskProcessorCleanupInterval.Get(dc),
  
  712
  >
  		ReplicationTaskProcessorCleanupJitterCoefficient:     dynamicconfig.ReplicationTaskProcessorCleanupJitterCoefficient.Get(dc),
  
  713
  >
  		ReplicationMultipleBatches:                           dynamicconfig.ReplicationMultipleBatches.Get(dc),
  
  714
  >
  
  715
  >
  		ReplicationStreamSenderErrorRetryWait:               dynamicconfig.ReplicationStreamSenderErrorRetryWait.Get(dc),
  
  716
  >
  		ReplicationStreamSenderErrorRetryBackoffCoefficient: dynamicconfig.ReplicationStreamSenderErrorRetryBackoffCoefficient.Get(dc),
  
  717
  >
  		ReplicationStreamSenderErrorRetryMaxInterval:        dynamicconfig.ReplicationStreamSenderErrorRetryMaxInterval.Get(dc),
  
  718
  >
  		ReplicationStreamSenderErrorRetryMaxAttempts:        dynamicconfig.ReplicationStreamSenderErrorRetryMaxAttempts.Get(dc),
  
  719
  >
  		ReplicationStreamSenderErrorRetryExpiration:         dynamicconfig.ReplicationStreamSenderErrorRetryExpiration.Get(dc),
  
  720
  >
  
  721
  >
  		ReplicationExecutableTaskErrorRetryWait:               dynamicconfig.ReplicationExecutableTaskErrorRetryWait.Get(dc),
  
  722
  >
  		ReplicationExecutableTaskErrorRetryBackoffCoefficient: dynamicconfig.ReplicationExecutableTaskErrorRetryBackoffCoefficient.Get(dc),
  
  723
  >
  		ReplicationExecutableTaskErrorRetryMaxInterval:        dynamicconfig.ReplicationExecutableTaskErrorRetryMaxInterval.Get(dc),
  
  724
  >
  		ReplicationExecutableTaskErrorRetryMaxAttempts:        dynamicconfig.ReplicationExecutableTaskErrorRetryMaxAttempts.Get(dc),
  
  725
  >
  		ReplicationExecutableTaskErrorRetryExpiration:         dynamicconfig.ReplicationExecutableTaskErrorRetryExpiration.Get(dc),
  
  726
  >
  
  727
  >
  		MaxBufferedQueryCount:                 dynamicconfig.MaxBufferedQueryCount.Get(dc),
  
  728
  >
  		MutableStateChecksumGenProbability:    dynamicconfig.MutableStateChecksumGenProbability.Get(dc),
  
  729
  >
  		MutableStateChecksumVerifyProbability: dynamicconfig.MutableStateChecksumVerifyProbability.Get(dc),
  
  730
  >
  		MutableStateChecksumInvalidateBefore:  dynamicconfig.MutableStateChecksumInvalidateBefore.Get(dc),
  
  731
  >
  
  732
  >
  		StandbyTaskReReplicationContextTimeout: dynamicconfig.StandbyTaskReReplicationContextTimeout.Get(dc),
  
  733
  >
  
  734
  >
  		SkipReapplicationByNamespaceID: dynamicconfig.SkipReapplicationByNamespaceID.Get(dc),
  
  735
  >
  
  736
  >
  		// ===== Visibility related =====
  
  737
  >
  		VisibilityTaskBatchSize:                               dynamicconfig.VisibilityTaskBatchSize.Get(dc),
  
  738
  >
  		VisibilityProcessorMaxPollRPS:                         dynamicconfig.VisibilityProcessorMaxPollRPS.Get(dc),
  
  739
  >
  		VisibilityProcessorMaxPollHostRPS:                     dynamicconfig.VisibilityProcessorMaxPollHostRPS.Get(dc),
  
  740
  >
  		VisibilityProcessorSchedulerWorkerCount:               dynamicconfig.VisibilityProcessorSchedulerWorkerCount.Subscribe(dc),
  
  741
  >
  		VisibilityProcessorSchedulerActiveRoundRobinWeights:   dynamicconfig.VisibilityProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),
  
  742
  >
  		VisibilityProcessorSchedulerStandbyRoundRobinWeights:  dynamicconfig.VisibilityProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),
  
  743
  >
  		VisibilityProcessorMaxPollInterval:                    dynamicconfig.VisibilityProcessorMaxPollInterval.Get(dc),
  
  744
  >
  		VisibilityProcessorMaxPollIntervalJitterCoefficient:   dynamicconfig.VisibilityProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  745
  >
  		VisibilityProcessorUpdateAckInterval:                  dynamicconfig.VisibilityProcessorUpdateAckInterval.Get(dc),
  
  746
  >
  		VisibilityProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.VisibilityProcessorUpdateAckIntervalJitterCoefficient.Get(dc),
  
  747
  >
  		VisibilityProcessorPollBackoffInterval:                dynamicconfig.VisibilityProcessorPollBackoffInterval.Get(dc),
  
  748
  >
  		VisibilityProcessorEnsureCloseBeforeDelete:            dynamicconfig.VisibilityProcessorEnsureCloseBeforeDelete.Get(dc),
  
  749
  >
  		VisibilityProcessorEnableCloseWorkflowCleanup:         dynamicconfig.VisibilityProcessorEnableCloseWorkflowCleanup.Get(dc),
  
  750
  >
  		VisibilityProcessorRelocateAttributesMinBlobSize:      dynamicconfig.VisibilityProcessorRelocateAttributesMinBlobSize.Get(dc),
  
  751
  >
  		VisibilityQueueMaxReaderCount:                         dynamicconfig.VisibilityQueueMaxReaderCount.Get(dc),
  
  752
  >
  
  753
  >
  		DisableFetchRelocatableAttributesFromVisibility: dynamicconfig.DisableFetchRelocatableAttributesFromVisibility.Get(dc),
  
  754
  >
  
  755
  >
  		SearchAttributesNumberOfKeysLimit: dynamicconfig.SearchAttributesNumberOfKeysLimit.Get(dc),
  
  756
  >
  		SearchAttributesSizeOfValueLimit:  dynamicconfig.SearchAttributesSizeOfValueLimit.Get(dc),
  
  757
  >
  		SearchAttributesTotalSizeLimit:    dynamicconfig.SearchAttributesTotalSizeLimit.Get(dc),
  
  758
  >
  		IndexerConcurrency:                dynamicconfig.WorkerIndexerConcurrency.Get(dc),
  
  759
  >
  		ESProcessorNumOfWorkers:           dynamicconfig.WorkerESProcessorNumOfWorkers.Get(dc),
  
  760
  >
  		// Should not be greater than number of visibility task queue workers VisibilityProcessorSchedulerWorkerCount (default 512)
  
  761
  >
  		// Otherwise, visibility queue processors won't be able to fill up bulk with documents (even under heavy load) and bulk will flush due to interval, not number of actions.
  
  762
  >
  		ESProcessorBulkActions: dynamicconfig.WorkerESProcessorBulkActions.Get(dc),
  
  763
  >
  		// 16MB - just a sanity check. With ES document size ~1Kb it should never be reached.
  
  764
  >
  		ESProcessorBulkSize: dynamicconfig.WorkerESProcessorBulkSize.Get(dc),
  
  765
  >
  		// Bulk processor will flush every this interval regardless of last flush due to bulk actions.
  
  766
  >
  		ESProcessorFlushInterval: dynamicconfig.WorkerESProcessorFlushInterval.Get(dc),
  
  767
  >
  		ESProcessorAckTimeout:    dynamicconfig.WorkerESProcessorAckTimeout.Get(dc),
  
  768
  >
  
  769
  >
  		EnableCrossNamespaceCommands:      dynamicconfig.EnableCrossNamespaceCommands.Get(dc),
  
  770
  >
  		EnableActivityEagerExecution:      dynamicconfig.EnableActivityEagerExecution.Get(dc),
  
  771
  >
  		EnableActivityRetryStampIncrement: dynamicconfig.EnableActivityRetryStampIncrement.Get(dc),
  
  772
  >
  		EnableCancelActivityWorkerCommand: dynamicconfig.EnableCancelActivityWorkerCommand.Get(dc),
  
  773
  >
  		EnableEagerWorkflowStart:          dynamicconfig.EnableEagerWorkflowStart.Get(dc),
  
  774
  >
  		NamespaceCacheRefreshInterval:     dynamicconfig.NamespaceCacheRefreshInterval.Get(dc),
  
  775
  >
  
  776
  >
  		// Archival related
  
  777
  >
  		ArchivalTaskBatchSize:                               dynamicconfig.ArchivalTaskBatchSize.Get(dc),
  
  778
  >
  		ArchivalProcessorMaxPollRPS:                         dynamicconfig.ArchivalProcessorMaxPollRPS.Get(dc),
  
  779
  >
  		ArchivalProcessorMaxPollHostRPS:                     dynamicconfig.ArchivalProcessorMaxPollHostRPS.Get(dc),
  
  780
  >
  		ArchivalProcessorSchedulerWorkerCount:               dynamicconfig.ArchivalProcessorSchedulerWorkerCount.Subscribe(dc),
  
  781
  >
  		ArchivalProcessorMaxPollInterval:                    dynamicconfig.ArchivalProcessorMaxPollInterval.Get(dc),
  
  782
  >
  		ArchivalProcessorMaxPollIntervalJitterCoefficient:   dynamicconfig.ArchivalProcessorMaxPollIntervalJitterCoefficient.Get(dc),
  
  783
  >
  		ArchivalProcessorUpdateAckInterval:                  dynamicconfig.ArchivalProcessorUpdateAckInterval.Get(dc),
  
  784
  >
  		ArchivalProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.ArchivalProcessorUpdateAckIntervalJitterCoefficient.Get(dc),
  
  785
  >
  		ArchivalProcessorPollBackoffInterval:                dynamicconfig.ArchivalProcessorPollBackoffInterval.Get(dc),
  
  786
  >
  		ArchivalProcessorArchiveDelay:                       dynamicconfig.ArchivalProcessorArchiveDelay.Get(dc),
  
  787
  >
  		ArchivalBackendMaxRPS:                               dynamicconfig.ArchivalBackendMaxRPS.Get(dc),
  
  788
  >
  		ArchivalQueueMaxReaderCount:                         dynamicconfig.ArchivalQueueMaxReaderCount.Get(dc),
  
  789
  >
  
  790
  >
  		// workflow update related
  
  791
  >
  		WorkflowExecutionMaxInFlightUpdates:                           dynamicconfig.WorkflowExecutionMaxInFlightUpdates.Get(dc),
  
  792
  >
  		WorkflowExecutionMaxInFlightUpdatePayloads:                    dynamicconfig.WorkflowExecutionMaxInFlightUpdatePayloads.Get(dc),
  
  793
  >
  		WorkflowExecutionMaxTotalUpdates:                              dynamicconfig.WorkflowExecutionMaxTotalUpdates.Get(dc),
  
  794
  >
  		WorkflowExecutionMaxTotalUpdatesSuggestContinueAsNewThreshold: dynamicconfig.WorkflowExecutionMaxTotalUpdatesSuggestContinueAsNewThreshold.Get(dc),
  
  795
  >
  		EnableUpdateWithStartRetryOnClosedWorkflowAbort:               dynamicconfig.EnableUpdateWithStartRetryOnClosedWorkflowAbort.Get(dc),
  
  796
  >
  		EnableUpdateWithStartRetryableErrorOnClosedWorkflowAbort:      dynamicconfig.EnableUpdateWithStartRetryableErrorOnClosedWorkflowAbort.Get(dc),
  
  797
  >
  
  798
  >
  		SendRawHistoryBetweenInternalServices:    dynamicconfig.SendRawHistoryBetweenInternalServices.Get(dc),
  
  799
  >
  		SendRawHistoryBytesToMatchingService:     dynamicconfig.SendRawHistoryBytesToMatchingService.Get(dc),
  
  800
  >
  		SendRawWorkflowHistory:                   dynamicconfig.SendRawWorkflowHistory.Get(dc),
  
  801
  >
  		WorkflowIdReuseMinimalInterval:           dynamicconfig.WorkflowIdReuseMinimalInterval.Get(dc),
  
  802
  >
  		EnableWorkflowIdReuseStartTimeValidation: dynamicconfig.EnableWorkflowIdReuseStartTimeValidation.Get(dc),
  
  803
  >
  		BusinessIDReuseRate:                      dynamicconfig.BusinessIDReuseRate.Get(dc),
  
  804
  >
  		BusinessIDReuseBurstRatio:                dynamicconfig.BusinessIDReuseBurstRatio.Get(dc),
  
  805
  >
  		BusinessIDReuseLimiterCacheSize:          dynamicconfig.BusinessIDReuseLimiterCacheSize.Get(dc),
  
  806
  >
  		BusinessIDReuseLimiterCacheTTL:           dynamicconfig.BusinessIDReuseLimiterCacheTTL.Get(dc),
  
  807
  >
  
  808
  >
  		HealthPersistenceLatencyFailure:     dynamicconfig.HealthPersistenceLatencyFailure.Get(dc),
  
  809
  >
  		HealthPersistenceLatencyPercentiles: dynamicconfig.PersistenceHealthSignalPercentileLatencySettings.Get(dc),
  
  810
  >
  		HealthPersistenceErrorRatio:         dynamicconfig.HealthPersistenceErrorRatio.Get(dc),
  
  811
  >
  		HealthRPCLatencyFailure:             dynamicconfig.HealthRPCLatencyFailure.Get(dc),
  
  812
  >
  		HealthRPCLatencyPercentiles:         dynamicconfig.HistoryHealthSignalPercentileLatencySettings.Get(dc),
  
  813
  >
  		HealthRPCErrorRatio:                 dynamicconfig.HealthRPCErrorRatio.Get(dc),
  
  814
  >
  		HealthHistoryInitializationTime:     dynamicconfig.HealthHistoryInitializationTime.Get(dc),
  
  815
  >
  
  816
  >
  		BreakdownMetricsByTaskQueue: dynamicconfig.MetricsBreakdownByTaskQueue.Get(dc),
  
  817
  >
  
  818
  >
  		LogAllReqErrors: dynamicconfig.LogAllReqErrors.Get(dc),
  
  819
  >
  
  820
  >
  		NumConsecutiveWorkflowTaskProblemsToTriggerSearchAttribute: dynamicconfig.NumConsecutiveWorkflowTaskProblemsToTriggerSearchAttribute.Get(dc),
  
  821
  >
  
  822
  >
  		// Worker-Versioning related
  
  823
  >
  		UseRevisionNumberForWorkerVersioning: dynamicconfig.UseRevisionNumberForWorkerVersioning.Get(dc),
  
  824
  >
  		EnableSuggestCaNOnNewTargetVersion:   dynamicconfig.EnableSuggestCaNOnNewTargetVersion.Get(dc),
  
  825
  >
  		EnableSendTargetVersionChanged:       dynamicconfig.EnableSendTargetVersionChanged.Get(dc),
  
  826
  >
  		VersionMembershipCacheTTL:            dynamicconfig.VersionMembershipCacheTTL.Get(dc),
  
  827
  >
  		VersionMembershipCacheMaxSize:        dynamicconfig.VersionMembershipCacheMaxSize.Get(dc),
  
  828
  >
  		EnableVersionReactivationSignals:     dynamicconfig.EnableVersionReactivationSignals.Get(dc),
  
  829
  >
  		RoutingInfoCacheTTL:                  dynamicconfig.RoutingInfoCacheTTL.Get(dc),
  
  830
  >
  		RoutingInfoCacheMaxSize:              dynamicconfig.RoutingInfoCacheMaxSize.Get(dc),
  
  831
  >
  
  832
  >
  		// Workflow task completion pagination
  
  833
  >
  		EnableWorkflowTaskCompletionPagination: dynamicconfig.EnableWorkflowTaskCompletionPagination.Get(dc),
  
  834
  >
  		WorkflowTaskCompletionBufferSizeLimit:  dynamicconfig.WorkflowTaskCompletionBufferSizeLimit.Get(dc),
  
  835
  >
  	}
  
  836
  >
  
  837
  >
  	return cfg
  
  838
  >
  }
  
  839
  
  840
  
  // GetShardID return the corresponding shard ID for a given namespaceID and workflowID pair

go.temporal.io/server/common/dynamicconfig/setting_gen.go 290 covered LOC · 67 ranges

Open complete file

  26
  
  type GlobalBoolConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[bool]
  
  27
  
  28
  >
  func NewGlobalBoolSetting(key string, def bool, description string) GlobalBoolSetting {
  
setting_gen.go

  29
  >
  	return NewGlobalTypedSettingWithConverter[bool](key, convertBool, def, description)
  
  30
  >
  }
  
  31
  
  32
  
  func NewGlobalBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) GlobalBoolConstrainedDefaultSetting {

  36
  
  type BoolPropertyFn = TypedPropertyFn[bool]
  
  37
  
  38
  >
  func GetBoolPropertyFn(value bool) BoolPropertyFn {
  
setting_gen.go

  39
  >
  	return GetTypedPropertyFn(value)
  
  40
  >
  }
  
  41
  
  42
  
  type NamespaceBoolSetting = NamespaceTypedSetting[bool]
  
  43
  
  type NamespaceBoolConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[bool]
  
  44
  
  45
  >
  func NewNamespaceBoolSetting(key string, def bool, description string) NamespaceBoolSetting {
  
setting_gen.go

  46
  >
  	return NewNamespaceTypedSettingWithConverter[bool](key, convertBool, def, description)
  
  47
  >
  }
  
  48
  
  49
  
  func NewNamespaceBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceBoolConstrainedDefaultSetting {

  53
  
  type BoolPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[bool]
  
  54
  
  55
  >
  func GetBoolPropertyFnFilteredByNamespace(value bool) BoolPropertyFnWithNamespaceFilter {
  
setting_gen.go

  56
  >
  	return GetTypedPropertyFnFilteredByNamespace(value)
  
  57
  >
  }
  
  58
  
  59
  
  type NamespaceIDBoolSetting = NamespaceIDTypedSetting[bool]
  
  60
  
  type NamespaceIDBoolConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[bool]
  
  61
  
  62
  >
  func NewNamespaceIDBoolSetting(key string, def bool, description string) NamespaceIDBoolSetting {
  
setting_gen.go

  63
  >
  	return NewNamespaceIDTypedSettingWithConverter[bool](key, convertBool, def, description)
  
  64
  >
  }
  
  65
  
  66
  
  func NewNamespaceIDBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceIDBoolConstrainedDefaultSetting {

  77
  
  type TaskQueueBoolConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[bool]
  
  78
  
  79
  >
  func NewTaskQueueBoolSetting(key string, def bool, description string) TaskQueueBoolSetting {
  
setting_gen.go

  80
  >
  	return NewTaskQueueTypedSettingWithConverter[bool](key, convertBool, def, description)
  
  81
  >
  }
  
  82
  
  83
  
  func NewTaskQueueBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) TaskQueueBoolConstrainedDefaultSetting {

  128
  
  type DestinationBoolConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[bool]
  
  129
  
  130
  >
  func NewDestinationBoolSetting(key string, def bool, description string) DestinationBoolSetting {
  
setting_gen.go

  131
  >
  	return NewDestinationTypedSettingWithConverter[bool](key, convertBool, def, description)
  
  132
  >
  }
  
  133
  
  134
  
  func NewDestinationBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) DestinationBoolConstrainedDefaultSetting {

  162
  
  type GlobalIntConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[int]
  
  163
  
  164
  >
  func NewGlobalIntSetting(key string, def int, description string) GlobalIntSetting {
  
setting_gen.go

  165
  >
  	return NewGlobalTypedSettingWithConverter[int](key, convertInt, def, description)
  
  166
  >
  }
  
  167
  
  168
  
  func NewGlobalIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) GlobalIntConstrainedDefaultSetting {

  179
  
  type NamespaceIntConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[int]
  
  180
  
  181
  >
  func NewNamespaceIntSetting(key string, def int, description string) NamespaceIntSetting {
  
setting_gen.go

  182
  >
  	return NewNamespaceTypedSettingWithConverter[int](key, convertInt, def, description)
  
  183
  >
  }
  
  184
  
  185
  
  func NewNamespaceIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) NamespaceIntConstrainedDefaultSetting {

  189
  
  type IntPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[int]
  
  190
  
  191
  >
  func GetIntPropertyFnFilteredByNamespace(value int) IntPropertyFnWithNamespaceFilter {
  
setting_gen.go

  192
  >
  	return GetTypedPropertyFnFilteredByNamespace(value)
  
  193
  >
  }
  
  194
  
  195
  
  type NamespaceIDIntSetting = NamespaceIDTypedSetting[int]

  213
  
  type TaskQueueIntConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[int]
  
  214
  
  215
  >
  func NewTaskQueueIntSetting(key string, def int, description string) TaskQueueIntSetting {
  
setting_gen.go

  216
  >
  	return NewTaskQueueTypedSettingWithConverter[int](key, convertInt, def, description)
  
  217
  >
  }
  
  218
  
  219
  >
  func NewTaskQueueIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) TaskQueueIntConstrainedDefaultSetting {
  
setting_gen.go

  220
  >
  	return NewTaskQueueTypedSettingWithConstrainedDefault[int](key, convertInt, cdef, description)
  
  221
  >
  }
  
  222
  
  223
  
  type IntPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[int]

  230
  
  type ShardIDIntConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[int]
  
  231
  
  232
  >
  func NewShardIDIntSetting(key string, def int, description string) ShardIDIntSetting {
  
setting_gen.go

  233
  >
  	return NewShardIDTypedSettingWithConverter[int](key, convertInt, def, description)
  
  234
  >
  }
  
  235
  
  236
  
  func NewShardIDIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) ShardIDIntConstrainedDefaultSetting {

  264
  
  type DestinationIntConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[int]
  
  265
  
  266
  >
  func NewDestinationIntSetting(key string, def int, description string) DestinationIntSetting {
  
setting_gen.go

  267
  >
  	return NewDestinationTypedSettingWithConverter[int](key, convertInt, def, description)
  
  268
  >
  }
  
  269
  
  270
  
  func NewDestinationIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) DestinationIntConstrainedDefaultSetting {

  298
  
  type GlobalFloatConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[float64]
  
  299
  
  300
  >
  func NewGlobalFloatSetting(key string, def float64, description string) GlobalFloatSetting {
  
setting_gen.go

  301
  >
  	return NewGlobalTypedSettingWithConverter[float64](key, convertFloat, def, description)
  
  302
  >
  }
  
  303
  
  304
  
  func NewGlobalFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) GlobalFloatConstrainedDefaultSetting {

  315
  
  type NamespaceFloatConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[float64]
  
  316
  
  317
  >
  func NewNamespaceFloatSetting(key string, def float64, description string) NamespaceFloatSetting {
  
setting_gen.go

  318
  >
  	return NewNamespaceTypedSettingWithConverter[float64](key, convertFloat, def, description)
  
  319
  >
  }
  
  320
  
  321
  
  func NewNamespaceFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) NamespaceFloatConstrainedDefaultSetting {

  349
  
  type TaskQueueFloatConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[float64]
  
  350
  
  351
  >
  func NewTaskQueueFloatSetting(key string, def float64, description string) TaskQueueFloatSetting {
  
setting_gen.go

  352
  >
  	return NewTaskQueueTypedSettingWithConverter[float64](key, convertFloat, def, description)
  
  353
  >
  }
  
  354
  
  355
  
  func NewTaskQueueFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) TaskQueueFloatConstrainedDefaultSetting {

  366
  
  type ShardIDFloatConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[float64]
  
  367
  
  368
  >
  func NewShardIDFloatSetting(key string, def float64, description string) ShardIDFloatSetting {
  
setting_gen.go

  369
  >
  	return NewShardIDTypedSettingWithConverter[float64](key, convertFloat, def, description)
  
  370
  >
  }
  
  371
  
  372
  
  func NewShardIDFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) ShardIDFloatConstrainedDefaultSetting {

  400
  
  type DestinationFloatConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[float64]
  
  401
  
  402
  >
  func NewDestinationFloatSetting(key string, def float64, description string) DestinationFloatSetting {
  
setting_gen.go

  403
  >
  	return NewDestinationTypedSettingWithConverter[float64](key, convertFloat, def, description)
  
  404
  >
  }
  
  405
  
  406
  
  func NewDestinationFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) DestinationFloatConstrainedDefaultSetting {

  434
  
  type GlobalStringConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[string]
  
  435
  
  436
  >
  func NewGlobalStringSetting(key string, def string, description string) GlobalStringSetting {
  
setting_gen.go

  437
  >
  	return NewGlobalTypedSettingWithConverter[string](key, convertString, def, description)
  
  438
  >
  }
  
  439
  
  440
  
  func NewGlobalStringSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[string], description string) GlobalStringConstrainedDefaultSetting {

  570
  
  type GlobalDurationConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[time.Duration]
  
  571
  
  572
  >
  func NewGlobalDurationSetting(key string, def time.Duration, description string) GlobalDurationSetting {
  
setting_gen.go

  573
  >
  	return NewGlobalTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  574
  >
  }
  
  575
  
  576
  
  func NewGlobalDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) GlobalDurationConstrainedDefaultSetting {

  580
  
  type DurationPropertyFn = TypedPropertyFn[time.Duration]
  
  581
  
  582
  >
  func GetDurationPropertyFn(value time.Duration) DurationPropertyFn {
  
setting_gen.go

  583
  >
  	return GetTypedPropertyFn(value)
  
  584
  >
  }
  
  585
  
  586
  
  type NamespaceDurationSetting = NamespaceTypedSetting[time.Duration]
  
  587
  
  type NamespaceDurationConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[time.Duration]
  
  588
  
  589
  >
  func NewNamespaceDurationSetting(key string, def time.Duration, description string) NamespaceDurationSetting {
  
setting_gen.go

  590
  >
  	return NewNamespaceTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  591
  >
  }
  
  592
  
  593
  
  func NewNamespaceDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceDurationConstrainedDefaultSetting {

  604
  
  type NamespaceIDDurationConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[time.Duration]
  
  605
  
  606
  >
  func NewNamespaceIDDurationSetting(key string, def time.Duration, description string) NamespaceIDDurationSetting {
  
setting_gen.go

  607
  >
  	return NewNamespaceIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  608
  >
  }
  
  609
  
  610
  
  func NewNamespaceIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceIDDurationConstrainedDefaultSetting {

  621
  
  type TaskQueueDurationConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[time.Duration]
  
  622
  
  623
  >
  func NewTaskQueueDurationSetting(key string, def time.Duration, description string) TaskQueueDurationSetting {
  
setting_gen.go

  624
  >
  	return NewTaskQueueTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  625
  >
  }
  
  626
  
  627
  >
  func NewTaskQueueDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskQueueDurationConstrainedDefaultSetting {
  
setting_gen.go

  628
  >
  	return NewTaskQueueTypedSettingWithConstrainedDefault[time.Duration](key, convertDuration, cdef, description)
  
  629
  >
  }
  
  630
  
  631
  
  type DurationPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[time.Duration]

  638
  
  type ShardIDDurationConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[time.Duration]
  
  639
  
  640
  >
  func NewShardIDDurationSetting(key string, def time.Duration, description string) ShardIDDurationSetting {
  
setting_gen.go

  641
  >
  	return NewShardIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  642
  >
  }
  
  643
  
  644
  
  func NewShardIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ShardIDDurationConstrainedDefaultSetting {

  655
  
  type TaskTypeDurationConstrainedDefaultSetting = TaskTypeTypedConstrainedDefaultSetting[time.Duration]
  
  656
  
  657
  >
  func NewTaskTypeDurationSetting(key string, def time.Duration, description string) TaskTypeDurationSetting {
  
setting_gen.go

  658
  >
  	return NewTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  659
  >
  }
  
  660
  
  661
  
  func NewTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskTypeDurationConstrainedDefaultSetting {

  672
  
  type DestinationDurationConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[time.Duration]
  
  673
  
  674
  >
  func NewDestinationDurationSetting(key string, def time.Duration, description string) DestinationDurationSetting {
  
setting_gen.go

  675
  >
  	return NewDestinationTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  676
  >
  }
  
  677
  
  678
  
  func NewDestinationDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) DestinationDurationConstrainedDefaultSetting {

  689
  
  type ChasmTaskTypeDurationConstrainedDefaultSetting = ChasmTaskTypeTypedConstrainedDefaultSetting[time.Duration]
  
  690
  
  691
  >
  func NewChasmTaskTypeDurationSetting(key string, def time.Duration, description string) ChasmTaskTypeDurationSetting {
  
setting_gen.go

  692
  >
  	return NewChasmTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)
  
  693
  >
  }
  
  694
  
  695
  
  func NewChasmTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ChasmTaskTypeDurationConstrainedDefaultSetting {

  723
  
  type NamespaceMapConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[map[string]any]
  
  724
  
  725
  >
  func NewNamespaceMapSetting(key string, def map[string]any, description string) NamespaceMapSetting {
  
setting_gen.go

  726
  >
  	return NewNamespaceTypedSettingWithConverter[map[string]any](key, convertMap, def, description)
  
  727
  >
  }
  
  728
  
  729
  
  func NewNamespaceMapSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[map[string]any], description string) NamespaceMapConstrainedDefaultSetting {

  845
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  846
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  847
  >
  func NewGlobalTypedSetting[T any](key string, def T, description string) GlobalTypedSetting[T] {
  
setting_gen.go

  848
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  849
  >
  	warnDefaultSharedStructure(key, def)
  
  850
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  851
  >
  	_ = deepCopyForMapstructure(def)
  
  852
  >
  
  853
  >
  	s := GlobalTypedSetting[T]{
  
  854
  >
  		key:         MakeKey(key),
  
  855
  >
  		def:         def,
  
  856
  >
  		convert:     ConvertStructure[T](def),
  
  857
  >
  		description: description,
  
  858
  >
  	}
  
  859
  >
  	register(s)
  
  860
  >
  	return s
  
  861
  >
  }
  
  862
  
  863
  
  // NewGlobalTypedSettingWithConverter creates a setting with a custom converter function.
  
  864
  >
  func NewGlobalTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) GlobalTypedSetting[T] {
  
setting_gen.go

  865
  >
  	s := GlobalTypedSetting[T]{
  
  866
  >
  		key:         MakeKey(key),
  
  867
  >
  		def:         def,
  
  868
  >
  		convert:     convert,
  
  869
  >
  		description: description,
  
  870
  >
  	}
  
  871
  >
  	register(s)
  
  872
  >
  	return s
  
  873
  >
  }
  
  874
  
  875
  
  // NewGlobalTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  885
  
  }
  
  886
  
  887
  >
  func (s GlobalTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  888
  
  func (s GlobalTypedSetting[T]) Precedence() Precedence { return PrecedenceGlobal }
  
  889
  
  func (s GlobalTypedSetting[T]) Validate(v any) error {

  907
  
  type TypedPropertyFn[T any] func() T
  
  908
  
  909
  >
  func (s GlobalTypedSetting[T]) Get(c *Collection) TypedPropertyFn[T] {
  
setting_gen.go

  910
  >
  	return func() T {
  
  911
  >
  		prec := []Constraints{{}}
  
setting_gen.go

  912
  >
  		return matchAndConvert(
  
  913
  >
  			c,
  
  914
  >
  			s.key,
  
  915
  >
  			s.def,
  
  916
  >
  			s.convert,
  
  917
  >
  			prec,
  
  918
  >
  		)
  
  919
  >
  	}
  
  920
  
  }
  
  921

  935
  
  type TypedSubscribable[T any] func(callback func(T)) (v T, cancel func())
  
  936
  
  937
  >
  func (s GlobalTypedSetting[T]) Subscribe(c *Collection) TypedSubscribable[T] {
  
setting_gen.go

  938
  >
  	return func(callback func(T)) (T, func()) {
  
  939
  
  		prec := []Constraints{{}}
  
  940
  
  		return subscribe(c, s.key, s.def, s.convert, prec, callback)

  969
  
  }
  
  970
  
  971
  >
  func GetTypedPropertyFn[T any](value T) TypedPropertyFn[T] {
  
setting_gen.go

  972
  >
  	return func() T {
  
  973
  
  		return value
  
  974
  
  	}

  981
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  982
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  983
  >
  func NewNamespaceTypedSetting[T any](key string, def T, description string) NamespaceTypedSetting[T] {
  
setting_gen.go

  984
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  985
  >
  	warnDefaultSharedStructure(key, def)
  
  986
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  987
  >
  	_ = deepCopyForMapstructure(def)
  
  988
  >
  
  989
  >
  	s := NamespaceTypedSetting[T]{
  
  990
  >
  		key:         MakeKey(key),
  
  991
  >
  		def:         def,
  
  992
  >
  		convert:     ConvertStructure[T](def),
  
  993
  >
  		description: description,
  
  994
  >
  	}
  
  995
  >
  	register(s)
  
  996
  >
  	return s
  
  997
  >
  }
  
  998
  
  999
  
  // NewNamespaceTypedSettingWithConverter creates a setting with a custom converter function.
  
  1000
  >
  func NewNamespaceTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceTypedSetting[T] {
  
setting_gen.go

  1001
  >
  	s := NamespaceTypedSetting[T]{
  
  1002
  >
  		key:         MakeKey(key),
  
  1003
  >
  		def:         def,
  
  1004
  >
  		convert:     convert,
  
  1005
  >
  		description: description,
  
  1006
  >
  	}
  
  1007
  >
  	register(s)
  
  1008
  >
  	return s
  
  1009
  >
  }
  
  1010
  
  1011
  
  // NewNamespaceTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1021
  
  }
  
  1022
  
  1023
  >
  func (s NamespaceTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1024
  
  func (s NamespaceTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespace }
  
  1025
  
  func (s NamespaceTypedSetting[T]) Validate(v any) error {

  1035
  
  }
  
  1036
  
  1037
  >
  func (s NamespaceTypedSetting[T]) WithDefault(v T) NamespaceTypedSetting[T] {
  
setting_gen.go

  1038
  >
  	newS := s
  
  1039
  >
  	newS.def = v
  
  1040
  >
  	return newS
  
  1041
  >
  }
  
  1042
  
  1043
  
  type TypedPropertyFnWithNamespaceFilter[T any] func(namespace string) T
  
  1044
  
  1045
  >
  func (s NamespaceTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithNamespaceFilter[T] {
  
setting_gen.go

  1046
  >
  	return func(namespace string) T {
  
  1047
  
  		prec := []Constraints{{Namespace: namespace}, {}}
  
  1048
  
  		return matchAndConvert(

  1105
  
  }
  
  1106
  
  1107
  >
  func GetTypedPropertyFnFilteredByNamespace[T any](value T) TypedPropertyFnWithNamespaceFilter[T] {
  
setting_gen.go

  1108
  >
  	return func(namespace string) T {
  
  1109
  
  		return value
  
  1110
  
  	}

  1134
  
  1135
  
  // NewNamespaceIDTypedSettingWithConverter creates a setting with a custom converter function.
  
  1136
  >
  func NewNamespaceIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceIDTypedSetting[T] {
  
setting_gen.go

  1137
  >
  	s := NamespaceIDTypedSetting[T]{
  
  1138
  >
  		key:         MakeKey(key),
  
  1139
  >
  		def:         def,
  
  1140
  >
  		convert:     convert,
  
  1141
  >
  		description: description,
  
  1142
  >
  	}
  
  1143
  >
  	register(s)
  
  1144
  >
  	return s
  
  1145
  >
  }
  
  1146
  
  1147
  
  // NewNamespaceIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1157
  
  }
  
  1158
  
  1159
  >
  func (s NamespaceIDTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1160
  
  func (s NamespaceIDTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespaceID }
  
  1161
  
  func (s NamespaceIDTypedSetting[T]) Validate(v any) error {

  1179
  
  type TypedPropertyFnWithNamespaceIDFilter[T any] func(namespaceID namespace.ID) T
  
  1180
  
  1181
  >
  func (s NamespaceIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithNamespaceIDFilter[T] {
  
setting_gen.go

  1182
  >
  	return func(namespaceID namespace.ID) T {
  
  1183
  
  		prec := []Constraints{{NamespaceID: namespaceID.String()}, {}}
  
  1184
  
  		return matchAndConvert(

  1253
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  1254
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  1255
  >
  func NewTaskQueueTypedSetting[T any](key string, def T, description string) TaskQueueTypedSetting[T] {
  
setting_gen.go

  1256
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  1257
  >
  	warnDefaultSharedStructure(key, def)
  
  1258
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  1259
  >
  	_ = deepCopyForMapstructure(def)
  
  1260
  >
  
  1261
  >
  	s := TaskQueueTypedSetting[T]{
  
  1262
  >
  		key:         MakeKey(key),
  
  1263
  >
  		def:         def,
  
  1264
  >
  		convert:     ConvertStructure[T](def),
  
  1265
  >
  		description: description,
  
  1266
  >
  	}
  
  1267
  >
  	register(s)
  
  1268
  >
  	return s
  
  1269
  >
  }
  
  1270
  
  1271
  
  // NewTaskQueueTypedSettingWithConverter creates a setting with a custom converter function.
  
  1272
  >
  func NewTaskQueueTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskQueueTypedSetting[T] {
  
setting_gen.go

  1273
  >
  	s := TaskQueueTypedSetting[T]{
  
  1274
  >
  		key:         MakeKey(key),
  
  1275
  >
  		def:         def,
  
  1276
  >
  		convert:     convert,
  
  1277
  >
  		description: description,
  
  1278
  >
  	}
  
  1279
  >
  	register(s)
  
  1280
  >
  	return s
  
  1281
  >
  }
  
  1282
  
  1283
  
  // NewTaskQueueTypedSettingWithConstrainedDefault creates a setting with a compound default value.
  
  1284
  >
  func NewTaskQueueTypedSettingWithConstrainedDefault[T any](key string, convert func(any) (T, error), cdef []TypedConstrainedValue[T], description string) TaskQueueTypedConstrainedDefaultSetting[T] {
  
setting_gen.go

  1285
  >
  	s := TaskQueueTypedConstrainedDefaultSetting[T]{
  
  1286
  >
  		key:         MakeKey(key),
  
  1287
  >
  		cdef:        cdef,
  
  1288
  >
  		convert:     convert,
  
  1289
  >
  		description: description,
  
  1290
  >
  	}
  
  1291
  >
  	register(s)
  
  1292
  >
  	return s
  
  1293
  >
  }
  
  1294
  
  1295
  >
  func (s TaskQueueTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1296
  
  func (s TaskQueueTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }
  
  1297
  
  func (s TaskQueueTypedSetting[T]) Validate(v any) error {

  1300
  
  }
  
  1301
  
  1302
  >
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1303
  
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }
  
  1304
  
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Validate(v any) error {

  1315
  
  type TypedPropertyFnWithTaskQueueFilter[T any] func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T
  
  1316
  
  1317
  >
  func (s TaskQueueTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskQueueFilter[T] {
  
setting_gen.go

  1318
  >
  	return func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T {
  
  1319
  
  		prec := []Constraints{
  
  1320
  
  			{Namespace: namespace, TaskQueueName: taskQueue, TaskQueueType: taskQueueType},

  1430
  
  1431
  
  // NewShardIDTypedSettingWithConverter creates a setting with a custom converter function.
  
  1432
  >
  func NewShardIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ShardIDTypedSetting[T] {
  
setting_gen.go

  1433
  >
  	s := ShardIDTypedSetting[T]{
  
  1434
  >
  		key:         MakeKey(key),
  
  1435
  >
  		def:         def,
  
  1436
  >
  		convert:     convert,
  
  1437
  >
  		description: description,
  
  1438
  >
  	}
  
  1439
  >
  	register(s)
  
  1440
  >
  	return s
  
  1441
  >
  }
  
  1442
  
  1443
  
  // NewShardIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1453
  
  }
  
  1454
  
  1455
  >
  func (s ShardIDTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1456
  
  func (s ShardIDTypedSetting[T]) Precedence() Precedence { return PrecedenceShardID }
  
  1457
  
  func (s ShardIDTypedSetting[T]) Validate(v any) error {

  1475
  
  type TypedPropertyFnWithShardIDFilter[T any] func(shardID int32) T
  
  1476
  
  1477
  >
  func (s ShardIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithShardIDFilter[T] {
  
setting_gen.go

  1478
  >
  	return func(shardID int32) T {
  
  1479
  
  		prec := []Constraints{{ShardID: shardID}, {}}
  
  1480
  
  		return matchAndConvert(

  1566
  
  1567
  
  // NewTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.
  
  1568
  >
  func NewTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskTypeTypedSetting[T] {
  
setting_gen.go

  1569
  >
  	s := TaskTypeTypedSetting[T]{
  
  1570
  >
  		key:         MakeKey(key),
  
  1571
  >
  		def:         def,
  
  1572
  >
  		convert:     convert,
  
  1573
  >
  		description: description,
  
  1574
  >
  	}
  
  1575
  >
  	register(s)
  
  1576
  >
  	return s
  
  1577
  >
  }
  
  1578
  
  1579
  
  // NewTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1589
  
  }
  
  1590
  
  1591
  >
  func (s TaskTypeTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1592
  
  func (s TaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskType }
  
  1593
  
  func (s TaskTypeTypedSetting[T]) Validate(v any) error {

  1611
  
  type TypedPropertyFnWithTaskTypeFilter[T any] func(taskType enumsspb.TaskType) T
  
  1612
  
  1613
  >
  func (s TaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskTypeFilter[T] {
  
setting_gen.go

  1614
  >
  	return func(taskType enumsspb.TaskType) T {
  
  1615
  
  		prec := []Constraints{{TaskType: taskType}, {}}
  
  1616
  
  		return matchAndConvert(

  1685
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  1686
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  1687
  >
  func NewDestinationTypedSetting[T any](key string, def T, description string) DestinationTypedSetting[T] {
  
setting_gen.go

  1688
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  1689
  >
  	warnDefaultSharedStructure(key, def)
  
  1690
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  1691
  >
  	_ = deepCopyForMapstructure(def)
  
  1692
  >
  
  1693
  >
  	s := DestinationTypedSetting[T]{
  
  1694
  >
  		key:         MakeKey(key),
  
  1695
  >
  		def:         def,
  
  1696
  >
  		convert:     ConvertStructure[T](def),
  
  1697
  >
  		description: description,
  
  1698
  >
  	}
  
  1699
  >
  	register(s)
  
  1700
  >
  	return s
  
  1701
  >
  }
  
  1702
  
  1703
  
  // NewDestinationTypedSettingWithConverter creates a setting with a custom converter function.
  
  1704
  >
  func NewDestinationTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) DestinationTypedSetting[T] {
  
setting_gen.go

  1705
  >
  	s := DestinationTypedSetting[T]{
  
  1706
  >
  		key:         MakeKey(key),
  
  1707
  >
  		def:         def,
  
  1708
  >
  		convert:     convert,
  
  1709
  >
  		description: description,
  
  1710
  >
  	}
  
  1711
  >
  	register(s)
  
  1712
  >
  	return s
  
  1713
  >
  }
  
  1714
  
  1715
  
  // NewDestinationTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1725
  
  }
  
  1726
  
  1727
  >
  func (s DestinationTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1728
  
  func (s DestinationTypedSetting[T]) Precedence() Precedence { return PrecedenceDestination }
  
  1729
  
  func (s DestinationTypedSetting[T]) Validate(v any) error {

  1747
  
  type TypedPropertyFnWithDestinationFilter[T any] func(namespace string, destination string) T
  
  1748
  
  1749
  >
  func (s DestinationTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithDestinationFilter[T] {
  
setting_gen.go

  1750
  >
  	return func(namespace string, destination string) T {
  
  1751
  
  		prec := []Constraints{
  
  1752
  
  			{Namespace: namespace, Destination: destination},

  1785
  
  type TypedSubscribableWithDestinationFilter[T any] func(namespace string, destination string, callback func(T)) (v T, cancel func())
  
  1786
  
  1787
  >
  func (s DestinationTypedSetting[T]) Subscribe(c *Collection) TypedSubscribableWithDestinationFilter[T] {
  
setting_gen.go

  1788
  >
  	return func(namespace string, destination string, callback func(T)) (T, func()) {
  
  1789
  
  		prec := []Constraints{
  
  1790
  
  			{Namespace: namespace, Destination: destination},

  1858
  
  1859
  
  // NewChasmTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.
  
  1860
  >
  func NewChasmTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ChasmTaskTypeTypedSetting[T] {
  
setting_gen.go

  1861
  >
  	s := ChasmTaskTypeTypedSetting[T]{
  
  1862
  >
  		key:         MakeKey(key),
  
  1863
  >
  		def:         def,
  
  1864
  >
  		convert:     convert,
  
  1865
  >
  		description: description,
  
  1866
  >
  	}
  
  1867
  >
  	register(s)
  
  1868
  >
  	return s
  
  1869
  >
  }
  
  1870
  
  1871
  
  // NewChasmTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1881
  
  }
  
  1882
  
  1883
  >
  func (s ChasmTaskTypeTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1884
  
  func (s ChasmTaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceChasmTaskType }
  
  1885
  
  func (s ChasmTaskTypeTypedSetting[T]) Validate(v any) error {

  1903
  
  type TypedPropertyFnWithChasmTaskTypeFilter[T any] func(chasmTaskType string) T
  
  1904
  
  1905
  >
  func (s ChasmTaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithChasmTaskTypeFilter[T] {
  
setting_gen.go

  1906
  >
  	return func(chasmTaskType string) T {
  
  1907
  
  		prec := []Constraints{{ChasmTaskType: chasmTaskType}, {}}
  
  1908
  
  		return matchAndConvert(

go.temporal.io/server/service/history/archival_queue_task_executor.go 156 covered LOC · 33 ranges

Open complete file

  36
  
  	metricsHandler metrics.Handler,
  
  37
  
  	logger log.Logger,
  
  38
  >
  ) queues.Executor {
  
archival_queue_task_executor.go

  39
  >
  	return &archivalQueueTaskExecutor{
  
  40
  >
  		archiver:                     archiver,
  
  41
  >
  		shardContext:                 shardContext,
  
  42
  >
  		workflowCache:                workflowCache,
  
  43
  >
  		relocatableAttributesFetcher: relocatableAttributesFetcher,
  
  44
  >
  		metricsHandler:               metricsHandler,
  
  45
  >
  		logger:                       logger,
  
  46
  >
  	}
  
  47
  >
  }
  
  48
  
  49
  
  // archivalQueueTaskExecutor is an implementation of queues.Executor for the archival queue.

  61
  
  	ctx context.Context,
  
  62
  
  	executable queues.Executable,
  
  63
  >
  ) queues.ExecuteResponse {
  
archival_queue_task_executor.go

  64
  >
  	task := executable.GetTask()
  
  65
  >
  	taskType := queues.GetArchivalTaskTypeTagValue(task)
  
  66
  >
  	tags := []metrics.Tag{
  
  67
  >
  		getNamespaceTagByID(e.shardContext.GetNamespaceRegistry(), task.GetNamespaceID()),
  
  68
  >
  		metrics.TaskTypeTag(taskType),
  
  69
  >
  		// OperationTag is for consistency on tags with other executors,
  
  70
  >
  		// since those tags will be used to emit a common set of metrics.
  
  71
  >
  		metrics.OperationTag(taskType),
  
  72
  >
  	}
  
  73
  >
  
  74
  >
  	var err error
  
  75
  >
  	switch task := task.(type) {
  
  76
  >
  	case *tasks.ArchiveExecutionTask:
  
archival_queue_task_executor.go

  77
  >
  		err = e.processArchiveExecutionTask(ctx, task)
  
  78
  >
  		if err == ErrMutableStateIsNil || err == ErrWorkflowExecutionIsStillRunning {
  
  79
  
  			// If either of these errors are returned, it means that we can just drop the task.
  
  80
  
  			err = nil

  83
  
  		err = fmt.Errorf("task with invalid type sent to archival queue: %+v", task)
  
  84
  
  	}
  
  85
  >
  	return queues.ExecuteResponse{
  
archival_queue_task_executor.go

  86
  >
  		ExecutionMetricTags: tags,
  
  87
  >
  		ExecutedAsActive:    true,
  
  88
  >
  		ExecutionErr:        err,
  
  89
  >
  	}
  
  90
  
  }
  
  91

  94
  
  // Second, we unlock the mutable state and send the archival request to the archival.Archiver.
  
  95
  
  // Finally, we lock the mutable state again, and send a deletion follow-up task to the history engine.
  
  96
  >
  func (e *archivalQueueTaskExecutor) processArchiveExecutionTask(ctx context.Context, task *tasks.ArchiveExecutionTask) (err error) {
  
archival_queue_task_executor.go

  97
  >
  	logger := log.With(e.logger, tag.Task(task))
  
  98
  >
  	request, err := e.getArchiveTaskRequest(ctx, logger, task)
  
  99
  >
  	if err != nil {
  
  100
  
  		return err
  
  101
  
  	}
  
  102
  >
  	if len(request.Targets) > 0 {
  
archival_queue_task_executor.go

  103
  >
  		_, err = e.archiver.Archive(ctx, request)
  
archival_queue_task_executor.go

  104
  >
  		if err != nil {
  
  105
  
  			return err
  
  106
  
  		}
  
  107
  
  	}
  
  108
  >
  	return e.addDeletionTask(ctx, logger, task, request.CloseTime.AsTime())
  
archival_queue_task_executor.go

  109
  
  }
  
  110

  114
  
  	logger log.Logger,
  
  115
  
  	task *tasks.ArchiveExecutionTask,
  
  116
  >
  ) (request *archival.Request, err error) {
  
archival_queue_task_executor.go

  117
  >
  	mutableState, err := e.loadAndVersionCheckMutableState(ctx, logger, task)
  
  118
  >
  	if err != nil {
  
  119
  
  		return nil, err
  
  120
  
  	}
  
  121
  >
  	defer func() {
  
archival_queue_task_executor.go

  122
  >
  		mutableState.Release(err)
  
  123
  >
  	}()
  
  124
  
  125
  >
  	namespaceEntry := mutableState.GetNamespaceEntry()
  
archival_queue_task_executor.go

  126
  >
  	namespaceName := namespaceEntry.Name()
  
  127
  >
  	nextEventID := mutableState.GetNextEventID()
  
  128
  >
  	executionInfo := mutableState.GetExecutionInfo()
  
  129
  >
  	executionState := mutableState.GetExecutionState()
  
  130
  >
  
  131
  >
  	logger = log.With(logger,
  
  132
  >
  		tag.WorkflowNamespaceID(executionInfo.NamespaceId),
  
  133
  >
  		tag.WorkflowID(executionInfo.WorkflowId),
  
  134
  >
  		tag.WorkflowRunID(executionState.RunId),
  
  135
  >
  	)
  
  136
  >
  
  137
  >
  	closeTime, err := mutableState.GetWorkflowCloseTime(ctx)
  
  138
  >
  	if err != nil {
  
  139
  
  		return nil, err
  
  140
  
  	}
  
  141
  >
  	executionDuration, err := mutableState.GetWorkflowExecutionDuration(ctx)
  
archival_queue_task_executor.go

  142
  >
  	if err != nil {
  
  143
  
  		return nil, err
  
  144
  
  	}
  
  145
  >
  	branchToken, err := mutableState.GetCurrentBranchToken()
  
archival_queue_task_executor.go

  146
  >
  	if err != nil {
  
  147
  
  		return nil, err
  
  148
  
  	}
  
  149
  
  150
  >
  	var historyURI, visibilityURI carchiver.URI
  
archival_queue_task_executor.go

  151
  >
  	var targets []archival.Target
  
  152
  >
  	if e.shardContext.GetArchivalMetadata().GetVisibilityConfig().ClusterConfiguredForArchival() &&
  
  153
  >
  		namespaceEntry.VisibilityArchivalState().State == enumspb.ARCHIVAL_STATE_ENABLED {
  
  154
  >
  		targets = append(targets, archival.TargetVisibility)
  
archival_queue_task_executor.go

  155
  >
  		visibilityURIString := namespaceEntry.VisibilityArchivalState().URI
  
  156
  >
  		visibilityURI, err = carchiver.NewURI(visibilityURIString)
  
  157
  >
  		if err != nil {
  
  158
  
  			metrics.ArchivalTaskInvalidURI.With(e.metricsHandler).Record(
  
  159
  
  				1,

  169
  
  		}
  
  170
  
  	}
  
  171
  >
  	if e.shardContext.GetArchivalMetadata().GetHistoryConfig().ClusterConfiguredForArchival() &&
  
archival_queue_task_executor.go

  172
  >
  		namespaceEntry.HistoryArchivalState().State == enumspb.ARCHIVAL_STATE_ENABLED {
  
  173
  >
  		historyURIString := namespaceEntry.HistoryArchivalState().URI
  
archival_queue_task_executor.go

  174
  >
  		historyURI, err = carchiver.NewURI(historyURIString)
  
  175
  >
  		if err != nil {
  
  176
  
  			metrics.ArchivalTaskInvalidURI.With(e.metricsHandler).Record(
  
  177
  
  				1,

  186
  
  			return nil, fmt.Errorf("failed to parse history URI for archival task: %w", err)
  
  187
  
  		}
  
  188
  >
  		targets = append(targets, archival.TargetHistory)
  
archival_queue_task_executor.go

  189
  
  	}
  
  190
  
  191
  >
  	workflowAttributes, err := e.relocatableAttributesFetcher.Fetch(ctx, mutableState)
  
archival_queue_task_executor.go

  192
  >
  	if err != nil {
  
  193
  
  		return nil, err
  
  194
  
  	}
  
  195
  
  196
  >
  	request = &archival.Request{
  
archival_queue_task_executor.go

  197
  >
  		ShardID:              e.shardContext.GetShardID(),
  
  198
  >
  		NamespaceID:          task.NamespaceID,
  
  199
  >
  		Namespace:            namespaceName.String(),
  
  200
  >
  		WorkflowID:           task.WorkflowID,
  
  201
  >
  		RunID:                task.RunID,
  
  202
  >
  		BranchToken:          branchToken,
  
  203
  >
  		NextEventID:          nextEventID,
  
  204
  >
  		CloseFailoverVersion: mutableState.CloseVersion,
  
  205
  >
  		HistoryURI:           historyURI,
  
  206
  >
  		VisibilityURI:        visibilityURI,
  
  207
  >
  		WorkflowTypeName:     executionInfo.GetWorkflowTypeName(),
  
  208
  >
  		StartTime:            executionState.GetStartTime(),
  
  209
  >
  		ExecutionTime:        executionInfo.GetExecutionTime(),
  
  210
  >
  		CloseTime:            timestamppb.New(closeTime),
  
  211
  >
  		ExecutionDuration:    durationpb.New(executionDuration),
  
  212
  >
  		Status:               executionState.Status,
  
  213
  >
  		HistoryLength:        nextEventID - 1,
  
  214
  >
  		Memo:                 workflowAttributes.Memo,
  
  215
  >
  		SearchAttributes:     workflowAttributes.SearchAttributes,
  
  216
  >
  		Targets:              targets,
  
  217
  >
  		CallerService:        string(primitives.HistoryService),
  
  218
  >
  	}
  
  219
  >
  	return request, nil
  
  220
  
  }
  
  221

  226
  
  	task *tasks.ArchiveExecutionTask,
  
  227
  
  	closeTime time.Time,
  
  228
  >
  ) error {
  
archival_queue_task_executor.go

  229
  >
  	mutableState, err := e.loadAndVersionCheckMutableState(ctx, logger, task)
  
  230
  >
  	if err != nil {
  
  231
  
  		return err
  
  232
  
  	}
  
  233
  >
  	defer func() {
  
archival_queue_task_executor.go

  234
  >
  		mutableState.Release(err)
  
  235
  >
  	}()
  
  236
  
  237
  >
  	taskGenerator := workflow.NewTaskGenerator(
  
archival_queue_task_executor.go

  238
  >
  		e.shardContext.GetNamespaceRegistry(),
  
  239
  >
  		mutableState,
  
  240
  >
  		e.shardContext.GetConfig(),
  
  241
  >
  		e.shardContext.GetArchivalMetadata(),
  
  242
  >
  		e.shardContext.GetLogger(),
  
  243
  >
  	)
  
  244
  >
  	err = taskGenerator.GenerateDeleteHistoryEventTask(closeTime)
  
  245
  >
  	if err != nil {
  
  246
  
  		return err
  
  247
  
  	}
  
  248
  >
  	err = e.shardContext.AddTasks(ctx, &persistence.AddHistoryTasksRequest{
  
archival_queue_task_executor.go

  249
  >
  		ShardID:     e.shardContext.GetShardID(),
  
  250
  >
  		NamespaceID: task.GetNamespaceID(),
  
  251
  >
  		WorkflowID:  task.WorkflowID,
  
  252
  >
  		ArchetypeID: chasm.WorkflowArchetypeID, // Archival is only supported for workflow now.
  
  253
  >
  		Tasks:       mutableState.PopTasks(),
  
  254
  >
  	})
  
  255
  >
  	return err
  
  256
  
  }
  
  257

  276
  
  	closeVersion int64,
  
  277
  
  	releaseFunc historyi.ReleaseWorkflowContextFunc,
  
  278
  >
  ) *lockedMutableState {
  
archival_queue_task_executor.go

  279
  >
  	return &lockedMutableState{
  
  280
  >
  		MutableState: mutableState,
  
  281
  >
  		CloseVersion: closeVersion,
  
  282
  >
  		Release:      releaseFunc,
  
  283
  >
  	}
  
  284
  >
  }
  
  285
  
  286
  
  var (

  298
  
  	logger log.Logger,
  
  299
  
  	task *tasks.ArchiveExecutionTask,
  
  300
  >
  ) (lockedMutableState *lockedMutableState, err error) {
  
archival_queue_task_executor.go

  301
  >
  	weContext, release, err := getWorkflowExecutionContextForTask(ctx, e.shardContext, e.workflowCache, task)
  
  302
  >
  	if err != nil {
  
  303
  
  		return nil, err
  
  304
  
  	}
  
  305
  >
  	defer func() {
  
archival_queue_task_executor.go

  306
  >
  		// If we return an error, the caller will not release the mutable state, so we need to do it here.
  
  307
  >
  		if err != nil {
  
  308
  
  			release(err)
  
  309
  
  		}

  311
  
  	}()
  
  312
  
  313
  >
  	mutableState, err := weContext.LoadMutableState(ctx, e.shardContext)
  
archival_queue_task_executor.go

  314
  >
  	if err != nil {
  
  315
  
  		return nil, err
  
  316
  
  	}
  
  317
  >
  	if mutableState == nil {
  
archival_queue_task_executor.go

  318
  
  		logger.Warn("Dropping archival task because mutable state is nil.")
  
  319
  
  		return nil, ErrMutableStateIsNil
  
  320
  
  	}
  
  321
  >
  	if mutableState.IsWorkflowExecutionRunning() {
  
archival_queue_task_executor.go

  322
  
  		logger.Warn("Dropping archival task because workflow is still running.")
  
  323
  
  		return nil, ErrWorkflowExecutionIsStillRunning
  
  324
  
  	}
  
  325
  >
  	closeVersion, err := mutableState.GetCloseVersion()
  
archival_queue_task_executor.go

  326
  >
  	if err != nil {
  
  327
  
  		return nil, err
  
  328
  
  	}
  
  329
  >
  	namespaceEntry := mutableState.GetNamespaceEntry()
  
archival_queue_task_executor.go

  330
  >
  	err = CheckTaskVersion(
  
  331
  >
  		e.shardContext,
  
  332
  >
  		logger,
  
  333
  >
  		namespaceEntry,
  
  334
  >
  		closeVersion,
  
  335
  >
  		task.GetVersion(),
  
  336
  >
  		task,
  
  337
  >
  	)
  
  338
  >
  	if err != nil {
  
  339
  
  		return nil, err
  
  340
  
  	}
  
  341
  >
  	return newLockedMutableState(mutableState, closeVersion, release), nil
  
archival_queue_task_executor.go

  342
  
  }

go.temporal.io/server/service/history/interfaces/mutable_state_mock.go 143 covered LOC · 28 ranges

Open complete file

  61
  
  62
  
  // NewMockMutableState creates a new mock instance.
  
  63
  >
  func NewMockMutableState(ctrl *gomock.Controller) *MockMutableState {
  
mutable_state_mock.go

  64
  >
  	mock := &MockMutableState{ctrl: ctrl}
  
  65
  >
  	mock.recorder = &MockMutableStateMockRecorder{mock}
  
  66
  >
  	return mock
  
  67
  >
  }
  
  68
  
  69
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  70
  >
  func (m *MockMutableState) EXPECT() *MockMutableStateMockRecorder {
  
mutable_state_mock.go

  71
  >
  	return m.recorder
  
  72
  >
  }
  
  73
  
  74
  
  // AddActivityTaskCancelRequestedEvent mocks base method.

  543
  
  544
  
  // AddTasks mocks base method.
  
  545
  >
  func (m *MockMutableState) AddTasks(arg0 ...tasks.Task) {
  
mutable_state_mock.go

  546
  >
  	m.ctrl.T.Helper()
  
  547
  >
  	varargs := []any{}
  
  548
  >
  	for _, a := range arg0 {
  
  549
  >
  		varargs = append(varargs, a)
  
  550
  >
  	}
  
  551
  >
  	m.ctrl.Call(m, "AddTasks", varargs...)
  
  552
  
  }
  
  553
  
  554
  
  // AddTasks indicates an expected call of AddTasks.
  
  555
  >
  func (mr *MockMutableStateMockRecorder) AddTasks(arg0 ...any) *gomock.Call {
  
mutable_state_mock.go

  556
  >
  	mr.mock.ctrl.T.Helper()
  
  557
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockMutableState)(nil).AddTasks), arg0...)
  
  558
  >
  }
  
  559
  
  560
  
  // AddTimeoutWorkflowEvent mocks base method.

  1738
  
  1739
  
  // ChasmTree mocks base method.
  
  1740
  >
  func (m *MockMutableState) ChasmTree() ChasmTree {
  
mutable_state_mock.go

  1741
  >
  	m.ctrl.T.Helper()
  
  1742
  >
  	ret := m.ctrl.Call(m, "ChasmTree")
  
  1743
  >
  	ret0, _ := ret[0].(ChasmTree)
  
  1744
  >
  	return ret0
  
  1745
  >
  }
  
  1746
  
  1747
  
  // ChasmTree indicates an expected call of ChasmTree.
  
  1748
  >
  func (mr *MockMutableStateMockRecorder) ChasmTree() *gomock.Call {
  
mutable_state_mock.go

  1749
  >
  	mr.mock.ctrl.T.Helper()
  
  1750
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmTree", reflect.TypeOf((*MockMutableState)(nil).ChasmTree))
  
  1751
  >
  }
  
  1752
  
  1753
  
  // ChasmWorkflowComponent mocks base method.

  2195
  
  2196
  
  // GetCloseVersion mocks base method.
  
  2197
  >
  func (m *MockMutableState) GetCloseVersion() (int64, error) {
  
mutable_state_mock.go

  2198
  >
  	m.ctrl.T.Helper()
  
  2199
  >
  	ret := m.ctrl.Call(m, "GetCloseVersion")
  
  2200
  >
  	ret0, _ := ret[0].(int64)
  
  2201
  >
  	ret1, _ := ret[1].(error)
  
  2202
  >
  	return ret0, ret1
  
  2203
  >
  }
  
  2204
  
  2205
  
  // GetCloseVersion indicates an expected call of GetCloseVersion.
  
  2206
  >
  func (mr *MockMutableStateMockRecorder) GetCloseVersion() *gomock.Call {
  
mutable_state_mock.go

  2207
  >
  	mr.mock.ctrl.T.Helper()
  
  2208
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCloseVersion", reflect.TypeOf((*MockMutableState)(nil).GetCloseVersion))
  
  2209
  >
  }
  
  2210
  
  2211
  
  // GetCompletionEvent mocks base method.

  2239
  
  2240
  
  // GetCurrentBranchToken mocks base method.
  
  2241
  >
  func (m *MockMutableState) GetCurrentBranchToken() ([]byte, error) {
  
mutable_state_mock.go

  2242
  >
  	m.ctrl.T.Helper()
  
  2243
  >
  	ret := m.ctrl.Call(m, "GetCurrentBranchToken")
  
  2244
  >
  	ret0, _ := ret[0].([]byte)
  
  2245
  >
  	ret1, _ := ret[1].(error)
  
  2246
  >
  	return ret0, ret1
  
  2247
  >
  }
  
  2248
  
  2249
  
  // GetCurrentBranchToken indicates an expected call of GetCurrentBranchToken.
  
  2250
  >
  func (mr *MockMutableStateMockRecorder) GetCurrentBranchToken() *gomock.Call {
  
mutable_state_mock.go

  2251
  >
  	mr.mock.ctrl.T.Helper()
  
  2252
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentBranchToken", reflect.TypeOf((*MockMutableState)(nil).GetCurrentBranchToken))
  
  2253
  >
  }
  
  2254
  
  2255
  
  // GetCurrentVersion mocks base method.

  2310
  
  2311
  
  // GetExecutionInfo mocks base method.
  
  2312
  >
  func (m *MockMutableState) GetExecutionInfo() *persistence.WorkflowExecutionInfo {
  
mutable_state_mock.go

  2313
  >
  	m.ctrl.T.Helper()
  
  2314
  >
  	ret := m.ctrl.Call(m, "GetExecutionInfo")
  
  2315
  >
  	ret0, _ := ret[0].(*persistence.WorkflowExecutionInfo)
  
  2316
  >
  	return ret0
  
  2317
  >
  }
  
  2318
  
  2319
  
  // GetExecutionInfo indicates an expected call of GetExecutionInfo.
  
  2320
  >
  func (mr *MockMutableStateMockRecorder) GetExecutionInfo() *gomock.Call {
  
mutable_state_mock.go

  2321
  >
  	mr.mock.ctrl.T.Helper()
  
  2322
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionInfo", reflect.TypeOf((*MockMutableState)(nil).GetExecutionInfo))
  
  2323
  >
  }
  
  2324
  
  2325
  
  // GetExecutionState mocks base method.
  
  2326
  >
  func (m *MockMutableState) GetExecutionState() *persistence.WorkflowExecutionState {
  
mutable_state_mock.go

  2327
  >
  	m.ctrl.T.Helper()
  
  2328
  >
  	ret := m.ctrl.Call(m, "GetExecutionState")
  
  2329
  >
  	ret0, _ := ret[0].(*persistence.WorkflowExecutionState)
  
  2330
  >
  	return ret0
  
  2331
  >
  }
  
  2332
  
  2333
  
  // GetExecutionState indicates an expected call of GetExecutionState.
  
  2334
  >
  func (mr *MockMutableStateMockRecorder) GetExecutionState() *gomock.Call {
  
mutable_state_mock.go

  2335
  >
  	mr.mock.ctrl.T.Helper()
  
  2336
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionState", reflect.TypeOf((*MockMutableState)(nil).GetExecutionState))
  
  2337
  >
  }
  
  2338
  
  2339
  
  // GetExternalPayloadCount mocks base method.

  2482
  
  2483
  
  // GetNamespaceEntry mocks base method.
  
  2484
  >
  func (m *MockMutableState) GetNamespaceEntry() *namespace.Namespace {
  
mutable_state_mock.go

  2485
  >
  	m.ctrl.T.Helper()
  
  2486
  >
  	ret := m.ctrl.Call(m, "GetNamespaceEntry")
  
  2487
  >
  	ret0, _ := ret[0].(*namespace.Namespace)
  
  2488
  >
  	return ret0
  
  2489
  >
  }
  
  2490
  
  2491
  
  // GetNamespaceEntry indicates an expected call of GetNamespaceEntry.
  
  2492
  >
  func (mr *MockMutableStateMockRecorder) GetNamespaceEntry() *gomock.Call {
  
mutable_state_mock.go

  2493
  >
  	mr.mock.ctrl.T.Helper()
  
  2494
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceEntry", reflect.TypeOf((*MockMutableState)(nil).GetNamespaceEntry))
  
  2495
  >
  }
  
  2496
  
  2497
  
  // GetNextEventID mocks base method.
  
  2498
  >
  func (m *MockMutableState) GetNextEventID() int64 {
  
mutable_state_mock.go

  2499
  >
  	m.ctrl.T.Helper()
  
  2500
  >
  	ret := m.ctrl.Call(m, "GetNextEventID")
  
  2501
  >
  	ret0, _ := ret[0].(int64)
  
  2502
  >
  	return ret0
  
  2503
  >
  }
  
  2504
  
  2505
  
  // GetNextEventID indicates an expected call of GetNextEventID.
  
  2506
  >
  func (mr *MockMutableStateMockRecorder) GetNextEventID() *gomock.Call {
  
mutable_state_mock.go

  2507
  >
  	mr.mock.ctrl.T.Helper()
  
  2508
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNextEventID", reflect.TypeOf((*MockMutableState)(nil).GetNextEventID))
  
  2509
  >
  }
  
  2510
  
  2511
  
  // GetPendingActivityInfos mocks base method.

  2871
  
  2872
  
  // GetWorkflowCloseTime mocks base method.
  
  2873
  >
  func (m *MockMutableState) GetWorkflowCloseTime(ctx context.Context) (time.Time, error) {
  
mutable_state_mock.go

  2874
  >
  	m.ctrl.T.Helper()
  
  2875
  >
  	ret := m.ctrl.Call(m, "GetWorkflowCloseTime", ctx)
  
  2876
  >
  	ret0, _ := ret[0].(time.Time)
  
  2877
  >
  	ret1, _ := ret[1].(error)
  
  2878
  >
  	return ret0, ret1
  
  2879
  >
  }
  
  2880
  
  2881
  
  // GetWorkflowCloseTime indicates an expected call of GetWorkflowCloseTime.
  
  2882
  >
  func (mr *MockMutableStateMockRecorder) GetWorkflowCloseTime(ctx any) *gomock.Call {
  
mutable_state_mock.go

  2883
  >
  	mr.mock.ctrl.T.Helper()
  
  2884
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowCloseTime", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowCloseTime), ctx)
  
  2885
  >
  }
  
  2886
  
  2887
  
  // GetWorkflowExecutionDuration mocks base method.
  
  2888
  >
  func (m *MockMutableState) GetWorkflowExecutionDuration(ctx context.Context) (time.Duration, error) {
  
mutable_state_mock.go

  2889
  >
  	m.ctrl.T.Helper()
  
  2890
  >
  	ret := m.ctrl.Call(m, "GetWorkflowExecutionDuration", ctx)
  
  2891
  >
  	ret0, _ := ret[0].(time.Duration)
  
  2892
  >
  	ret1, _ := ret[1].(error)
  
  2893
  >
  	return ret0, ret1
  
  2894
  >
  }
  
  2895
  
  2896
  
  // GetWorkflowExecutionDuration indicates an expected call of GetWorkflowExecutionDuration.
  
  2897
  >
  func (mr *MockMutableStateMockRecorder) GetWorkflowExecutionDuration(ctx any) *gomock.Call {
  
mutable_state_mock.go

  2898
  >
  	mr.mock.ctrl.T.Helper()
  
  2899
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionDuration", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowExecutionDuration), ctx)
  
  2900
  >
  }
  
  2901
  
  2902
  
  // GetWorkflowKey mocks base method.
  
  2903
  >
  func (m *MockMutableState) GetWorkflowKey() definition.WorkflowKey {
  
mutable_state_mock.go

  2904
  >
  	m.ctrl.T.Helper()
  
  2905
  >
  	ret := m.ctrl.Call(m, "GetWorkflowKey")
  
  2906
  >
  	ret0, _ := ret[0].(definition.WorkflowKey)
  
  2907
  >
  	return ret0
  
  2908
  >
  }
  
  2909
  
  2910
  
  // GetWorkflowKey indicates an expected call of GetWorkflowKey.
  
  2911
  >
  func (mr *MockMutableStateMockRecorder) GetWorkflowKey() *gomock.Call {
  
mutable_state_mock.go

  2912
  >
  	mr.mock.ctrl.T.Helper()
  
  2913
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowKey", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowKey))
  
  2914
  >
  }
  
  2915
  
  2916
  
  // GetWorkflowStateStatus mocks base method.

  3307
  
  3308
  
  // IsWorkflowExecutionRunning mocks base method.
  
  3309
  >
  func (m *MockMutableState) IsWorkflowExecutionRunning() bool {
  
mutable_state_mock.go

  3310
  >
  	m.ctrl.T.Helper()
  
  3311
  >
  	ret := m.ctrl.Call(m, "IsWorkflowExecutionRunning")
  
  3312
  >
  	ret0, _ := ret[0].(bool)
  
  3313
  >
  	return ret0
  
  3314
  >
  }
  
  3315
  
  3316
  
  // IsWorkflowExecutionRunning indicates an expected call of IsWorkflowExecutionRunning.
  
  3317
  >
  func (mr *MockMutableStateMockRecorder) IsWorkflowExecutionRunning() *gomock.Call {
  
mutable_state_mock.go

  3318
  >
  	mr.mock.ctrl.T.Helper()
  
  3319
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionRunning", reflect.TypeOf((*MockMutableState)(nil).IsWorkflowExecutionRunning))
  
  3320
  >
  }
  
  3321
  
  3322
  
  // IsWorkflowExecutionStatusPaused mocks base method.

  3392
  
  3393
  
  // PopTasks mocks base method.
  
  3394
  >
  func (m *MockMutableState) PopTasks() map[tasks.Category][]tasks.Task {
  
mutable_state_mock.go

  3395
  >
  	m.ctrl.T.Helper()
  
  3396
  >
  	ret := m.ctrl.Call(m, "PopTasks")
  
  3397
  >
  	ret0, _ := ret[0].(map[tasks.Category][]tasks.Task)
  
  3398
  >
  	return ret0
  
  3399
  >
  }
  
  3400
  
  3401
  
  // PopTasks indicates an expected call of PopTasks.
  
  3402
  >
  func (mr *MockMutableStateMockRecorder) PopTasks() *gomock.Call {
  
mutable_state_mock.go

  3403
  >
  	mr.mock.ctrl.T.Helper()
  
  3404
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopTasks", reflect.TypeOf((*MockMutableState)(nil).PopTasks))
  
  3405
  >
  }
  
  3406
  
  3407
  
  // RecordLastActivityCompleteTime mocks base method.

go.temporal.io/server/service/history/queues/executable.go 117 covered LOC · 25 ranges

Open complete file

  194
  
  	tracer trace.Tracer,
  
  195
  
  	opts ...ExecutableOption,
  
  196
  >
  ) Executable {
  
executable.go

  197
  >
  	params := ExecutableParams{
  
  198
  >
  		DLQEnabled: func() bool {
  
  199
  
  			return false
  
  200
  
  		},

  210
  
  		},
  
  211
  
  	}
  
  212
  >
  	for _, opt := range opts {
  
executable.go

  213
  
  		opt(&params)
  
  214
  
  	}
  
  215
  >
  	e := &executableImpl{
  
executable.go

  216
  >
  		Task:  task,
  
  217
  >
  		state: ctasks.TaskStatePending,
  
  218
  >
  
  219
  >
  		executor:            executor,
  
  220
  >
  		scheduler:           scheduler,
  
  221
  >
  		rescheduler:         rescheduler,
  
  222
  >
  		priorityAssigner:    priorityAssigner,
  
  223
  >
  		timeSource:          timeSource,
  
  224
  >
  		namespaceRegistry:   namespaceRegistry,
  
  225
  >
  		clusterMetadata:     clusterMetadata,
  
  226
  >
  		chasmRegistry:       chasmRegistry,
  
  227
  >
  		taskTypeTagProvider: taskTypeTagProvider,
  
  228
  >
  		readerID:            readerID,
  
  229
  >
  		logger: log.NewLazyLogger(
  
  230
  >
  			logger,
  
  231
  >
  			func() []tag.Tag {
  
  232
  
  				return tasks.Tags(task)
  
  233
  
  			},

  241
  
  		dlqErrorPattern:            params.DLQErrorPattern,
  
  242
  
  	}
  
  243
  >
  	e.refreshMetricsHandlers(nil)
  
executable.go

  244
  >
  	e.attempt.Store(1)
  
  245
  >
  	e.priority = priorityAssigner.Assign(e)
  
  246
  >
  
  247
  >
  	loadTime := util.MaxTime(timeSource.Now(), task.GetKey().FireTime)
  
  248
  >
  	metrics.TaskLoadLatency.With(e.chasmMetricsHandler).Record(
  
  249
  >
  		loadTime.Sub(task.GetVisibilityTime()),
  
  250
  >
  		metrics.QueueReaderIDTag(readerID),
  
  251
  >
  	)
  
  252
  >
  	return e
  
  253
  
  }
  
  254
  
  255
  >
  func (e *executableImpl) Execute() (retErr error) {
  
executable.go

  256
  >
  	startTime := e.timeSource.Now()
  
  257
  >
  	e.scheduleLatency = startTime.Sub(e.scheduledTime)
  
  258
  >
  
  259
  >
  	e.Lock()
  
  260
  >
  	if e.state != ctasks.TaskStatePending {
  
  261
  
  		e.Unlock()
  
  262
  
  		return nil
  
  263
  
  	}
  
  264
  
  265
  >
  	ns, _ := e.namespaceRegistry.GetNamespaceName(namespace.ID(e.GetNamespaceID()))
  
executable.go

  266
  >
  	var callerInfo headers.CallerInfo
  
  267
  >
  	switch e.priority {
  
  268
  >
  	case ctasks.PriorityHigh:
  
  269
  >
  		callerInfo = headers.NewBackgroundHighCallerInfo(ns.String())
  
  270
  
  	case ctasks.PriorityLow:
  
  271
  
  		callerInfo = headers.NewBackgroundLowCallerInfo(ns.String())

  274
  
  		callerInfo = headers.NewPreemptableCallerInfo(ns.String())
  
  275
  
  	}
  
  276
  >
  	ctx := headers.SetCallerInfo(
  
executable.go

  277
  >
  		metrics.AddMetricsContext(context.Background()),
  
  278
  >
  		callerInfo,
  
  279
  >
  	)
  
  280
  >
  	e.Unlock()
  
  281
  >
  
  282
  >
  	// Wrapped in if block to avoid unnecessary allocations when OTEL is disabled.
  
  283
  >
  	if telemetry.IsEnabled(e.tracer) {
  
  284
  
  		var span trace.Span
  
  285

  323
  
  	}
  
  324
  
  325
  >
  	defer func() {
  
executable.go

  326
  >
  		if pObj := recover(); pObj != nil {
  
  327
  
  			err, ok := pObj.(error)
  
  328
  
  			if !ok {

  338
  
  		}
  
  339
  
  340
  >
  		attemptUserLatency := time.Duration(0)
  
executable.go

  341
  >
  		if duration, ok := metrics.ContextCounterGet(ctx, metrics.HistoryWorkflowExecutionCacheLatency.Name()); ok {
  
  342
  
  			attemptUserLatency = time.Duration(duration)
  
  343
  
  		}
  
  344
  
  345
  >
  		attemptLatency := e.timeSource.Now().Sub(startTime)
  
executable.go

  346
  >
  		e.attemptNoUserLatency = attemptLatency - attemptUserLatency
  
  347
  >
  		// emit total attempt latency so that we know how much time a task will occpy a worker goroutine
  
  348
  >
  		metrics.TaskProcessingLatency.With(e.chasmMetricsHandler).Record(attemptLatency)
  
  349
  >
  
  350
  >
  		if persistenceDuration, ok := metrics.ContextCounterGet(ctx, metrics.TaskPersistenceLatency.Name()); ok {
  
  351
  
  			attemptNoPersistence := attemptLatency - time.Duration(persistenceDuration)
  
  352
  
  			metrics.TaskProcessingNoPersistenceLatency.With(e.chasmMetricsHandler).Record(attemptNoPersistence)
  
  353
  
  		}
  
  354
  
  355
  >
  		priorityTaggedProvider := e.chasmMetricsHandler.WithTags(metrics.TaskPriorityTag(e.priority.String()))
  
executable.go

  356
  >
  		metrics.TaskRequests.With(priorityTaggedProvider).Record(1)
  
  357
  >
  		metrics.TaskScheduleLatency.With(priorityTaggedProvider).Record(e.scheduleLatency)
  
  358
  >
  		metrics.OperationCounter.With(e.defaultMetricsHandler).Record(1)
  
  359
  >
  
  360
  >
  		if retErr == nil {
  
  361
  >
  			e.inMemoryNoUserLatency += e.scheduleLatency + e.attemptNoUserLatency
  
executable.go

  362
  >
  		}
  
  363
  
  		// if retErr is not nil, HandleErr will take care of the inMemoryNoUserLatency calculation
  
  364
  
  		// Not doing it here as for certain errors latency for the attempt should not be counted

  367
  
  	// A previous attempt has marked this executable as no longer retryable.
  
  368
  
  	// Instead of executing it, we try to write to the DLQ if enabled, otherwise - drop it.
  
  369
  >
  	if e.terminalFailureCause != nil {
  
executable.go

  370
  
  		if e.dlqEnabled() {
  
  371
  
  			return e.writeToDLQ(ctx)

  382
  
  	}
  
  383
  
  384
  >
  	resp := e.executor.Execute(ctx, e)
  
executable.go

  385
  >
  	e.refreshMetricsHandlers(resp.ExecutionMetricTags)
  
  386
  >
  
  387
  >
  	if resp.ExecutedAsActive != e.lastActiveness {
  
  388
  >
  		// namespace did a failover,
  
executable.go

  389
  >
  		// reset task attempt since the execution logic used will change
  
  390
  >
  		// reset task priority since it changes between active/standby
  
  391
  >
  		e.resetAttempt()
  
  392
  >
  		e.priority = e.priorityAssigner.Assign(e)
  
  393
  >
  	}
  
  394
  >
  	e.lastActiveness = resp.ExecutedAsActive
  
executable.go

  395
  >
  
  396
  >
  	return resp.ExecutionErr
  
  397
  
  }
  
  398

  762
  
  }
  
  763
  
  764
  >
  func (e *executableImpl) GetTask() tasks.Task {
  
executable.go

  765
  >
  	return e.Task
  
  766
  >
  }
  
  767
  
  768
  
  func (e *executableImpl) GetScheduledTime() time.Time {

  856
  
  }
  
  857
  
  858
  >
  func (e *executableImpl) resetAttempt() {
  
executable.go

  859
  >
  	e.attempt.Store(1)
  
  860
  >
  }
  
  861
  
  862
  >
  func (e *executableImpl) refreshMetricsHandlers(executionMetricTags []metrics.Tag) {
  
executable.go

  863
  >
  	sharedTags := taskBaseMetricTagsWithoutArchetype(
  
  864
  >
  		e.GetTask(),
  
  865
  >
  		e.namespaceRegistry,
  
  866
  >
  		e.clusterMetadata.GetCurrentClusterName(),
  
  867
  >
  		e.chasmRegistry,
  
  868
  >
  		e.taskTypeTagProvider,
  
  869
  >
  	)
  
  870
  >
  	if len(executionMetricTags) > 0 {
  
  871
  >
  		sharedTags = append(sharedTags, executionMetricTags...)
  
executable.go

  872
  >
  	}
  
  873
  >
  	e.defaultMetricsHandler = e.baseMetricsHandler.WithTags(sharedTags...)
  
executable.go

  874
  >
  	e.chasmMetricsHandler = e.defaultMetricsHandler.WithTags(getArchetypeTag(e.GetTask(), e.chasmRegistry))
  
  875
  
  }
  
  876

  892
  
  	chasmRegistry *chasm.Registry,
  
  893
  
  	taskTypeTagProvider TaskTypeTagProvider,
  
  894
  >
  ) []metrics.Tag {
  
executable.go

  895
  >
  	namespaceTag := metrics.NamespaceUnknownTag()
  
  896
  >
  	isActive := true
  
  897
  >
  
  898
  >
  	ns, err := namespaceRegistry.GetNamespaceByID(namespace.ID(task.GetNamespaceID()))
  
  899
  >
  	if err == nil {
  
  900
  
  		namespaceTag = metrics.NamespaceTag(ns.Name().String())
  
  901
  
  		isActive = ns.ActiveClusterName(namespace.RoutingKey{ID: task.GetWorkflowID()}) == currentClusterName
  
  902
  
  	}
  
  903
  
  904
  >
  	taskType := taskTypeTagProvider(task, isActive, chasmRegistry)
  
executable.go

  905
  >
  	return []metrics.Tag{
  
  906
  >
  		namespaceTag,
  
  907
  >
  		metrics.TaskTypeTag(taskType),
  
  908
  >
  		metrics.OperationTag(taskType), // for backward compatibility
  
  909
  >
  		// TODO: add task priority tag here as well
  
  910
  >
  	}
  
  911
  
  }
  
  912
  
  913
  >
  func getArchetypeTag(task tasks.Task, chasmRegistry *chasm.Registry) metrics.Tag {
  
executable.go

  914
  >
  	if t, ok := task.(tasks.HasArchetypeID); ok {
  
  915
  
  		if name, ok := chasmRegistry.ArchetypeDisplayName(t.GetArchetypeID()); ok {
  
  916
  
  			return metrics.ArchetypeTag(name)
  
  917
  
  		}
  
  918
  
  	}
  
  919
  >
  	return metrics.ArchetypeTag(chasm.WorkflowComponentName)
  
executable.go

  920
  
  }
  
  921

go.temporal.io/server/chasm/search_attribute.go 111 covered LOC · 16 ranges

Open complete file

  136
  
  }
  
  137
  
  138
  >
  func newSearchAttributeFieldBool(index int) SearchAttributeFieldBool {
  
search_attribute.go

  139
  >
  	return SearchAttributeFieldBool{
  
  140
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_BOOL, index),
  
  141
  >
  	}
  
  142
  >
  }
  
  143
  
  144
  
  // SearchAttributeFieldDateTime is a search attribute field for a datetime value.

  147
  
  }
  
  148
  
  149
  >
  func newSearchAttributeFieldDateTime(index int) SearchAttributeFieldDateTime {
  
search_attribute.go

  150
  >
  	return SearchAttributeFieldDateTime{
  
  151
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DATETIME, index),
  
  152
  >
  	}
  
  153
  >
  }
  
  154
  
  155
  
  // SearchAttributeFieldInt is a search attribute field for an integer value.

  158
  
  }
  
  159
  
  160
  >
  func newSearchAttributeFieldInt(index int) SearchAttributeFieldInt {
  
search_attribute.go

  161
  >
  	return SearchAttributeFieldInt{
  
  162
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_INT, index),
  
  163
  >
  	}
  
  164
  >
  }
  
  165
  
  166
  
  // SearchAttributeFieldDouble is a search attribute field for a double value.

  169
  
  }
  
  170
  
  171
  >
  func newSearchAttributeFieldDouble(index int) SearchAttributeFieldDouble {
  
search_attribute.go

  172
  >
  	return SearchAttributeFieldDouble{
  
  173
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DOUBLE, index),
  
  174
  >
  	}
  
  175
  >
  }
  
  176
  
  177
  
  // SearchAttributeFieldKeyword is a search attribute field for a keyword value.

  180
  
  }
  
  181
  
  182
  >
  func newSearchAttributeFieldKeyword(index int) SearchAttributeFieldKeyword {
  
search_attribute.go

  183
  >
  	return SearchAttributeFieldKeyword{
  
  184
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD, index),
  
  185
  >
  	}
  
  186
  >
  }
  
  187
  
  188
  >
  func newSearchAttributeFieldLowCardinalityKeyword(index int) SearchAttributeFieldKeyword {
  
search_attribute.go

  189
  >
  	return SearchAttributeFieldKeyword{
  
  190
  >
  		field: fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, "LowCardinalityKeyword", index),
  
  191
  >
  	}
  
  192
  >
  }
  
  193
  
  194
  
  // SearchAttributeFieldKeywordList is a search attribute field for a keyword list value.

  197
  
  }
  
  198
  
  199
  >
  func newSearchAttributeFieldKeywordList(index int) SearchAttributeFieldKeywordList {
  
search_attribute.go

  200
  >
  	return SearchAttributeFieldKeywordList{
  
  201
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST, index),
  
  202
  >
  	}
  
  203
  >
  }
  
  204
  
  205
  
  // SearchAttributeFieldText is a search attribute field for a text value.

  214
  
  }
  
  215
  
  216
  >
  func resolveFieldName(valueType enumspb.IndexedValueType, index int) string {
  
search_attribute.go

  217
  >
  	// Columns are named like TemporalBool01, TemporalDatetime01, TemporalDouble01, TemporalInt01.
  
  218
  >
  	return fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, valueType.String(), index)
  
  219
  >
  }
  
  220
  
  221
  
  func (s searchAttributeDefinition) definition() searchAttributeDefinition {

  229
  
  230
  
  // NewSearchAttributeBool creates a new boolean search attribute given a predefined chasm field
  
  231
  >
  func NewSearchAttributeBool(alias string, boolField SearchAttributeFieldBool) SearchAttributeBool {
  
search_attribute.go

  232
  >
  	return SearchAttributeBool{
  
  233
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  234
  >
  			alias:     alias,
  
  235
  >
  			field:     boolField.field,
  
  236
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,
  
  237
  >
  		},
  
  238
  >
  	}
  
  239
  >
  }
  
  240
  
  241
  >
  func newSearchAttributeBoolByField(field string) SearchAttributeBool {
  
search_attribute.go

  242
  >
  	return SearchAttributeBool{
  
  243
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  244
  >
  			alias:     field,
  
  245
  >
  			field:     field,
  
  246
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,
  
  247
  >
  		},
  
  248
  >
  	}
  
  249
  >
  }
  
  250
  
  251
  
  // Value sets the boolean value of the search attribute.

  266
  
  267
  
  // NewSearchAttributeDateTime creates a new date time search attribute given a predefined chasm field
  
  268
  >
  func NewSearchAttributeDateTime(alias string, datetimeField SearchAttributeFieldDateTime) SearchAttributeDateTime {
  
search_attribute.go

  269
  >
  	return SearchAttributeDateTime{
  
  270
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  271
  >
  			alias:     alias,
  
  272
  >
  			field:     datetimeField.field,
  
  273
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,
  
  274
  >
  		},
  
  275
  >
  	}
  
  276
  >
  }
  
  277
  
  278
  >
  func newSearchAttributeDateTimeByField(field string) SearchAttributeDateTime {
  
search_attribute.go

  279
  >
  	return SearchAttributeDateTime{
  
  280
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  281
  >
  			alias:     field,
  
  282
  >
  			field:     field,
  
  283
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,
  
  284
  >
  		},
  
  285
  >
  	}
  
  286
  >
  }
  
  287
  
  288
  
  // Value sets the date time value of the search attribute.

  303
  
  304
  
  // NewSearchAttributeInt creates a new integer search attribute given a predefined chasm field
  
  305
  >
  func NewSearchAttributeInt(alias string, intField SearchAttributeFieldInt) SearchAttributeInt {
  
search_attribute.go

  306
  >
  	return SearchAttributeInt{
  
  307
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  308
  >
  			alias:     alias,
  
  309
  >
  			field:     intField.field,
  
  310
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_INT,
  
  311
  >
  		},
  
  312
  >
  	}
  
  313
  >
  }
  
  314
  
  315
  
  // Value sets the integer value of the search attribute.

  367
  
  368
  
  // NewSearchAttributeKeyword creates a new keyword search attribute given a predefined chasm field
  
  369
  >
  func NewSearchAttributeKeyword(alias string, keywordField SearchAttributeFieldKeyword) SearchAttributeKeyword {
  
search_attribute.go

  370
  >
  	return SearchAttributeKeyword{
  
  371
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  372
  >
  			alias:     alias,
  
  373
  >
  			field:     keywordField.field,
  
  374
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,
  
  375
  >
  		},
  
  376
  >
  	}
  
  377
  >
  }
  
  378
  
  379
  >
  func newSearchAttributeKeywordByField(field string) SearchAttributeKeyword {
  
search_attribute.go

  380
  >
  	return SearchAttributeKeyword{
  
  381
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  382
  >
  			alias:     field,
  
  383
  >
  			field:     field,
  
  384
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,
  
  385
  >
  		},
  
  386
  >
  	}
  
  387
  >
  }
  
  388
  
  389
  
  // Value sets the string value of the search attribute.

  414
  
  }
  
  415
  
  416
  >
  func newSearchAttributeKeywordListByField(field string) SearchAttributeKeywordList {
  
search_attribute.go

  417
  >
  	return SearchAttributeKeywordList{
  
  418
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  419
  >
  			alias:     field,
  
  420
  >
  			field:     field,
  
  421
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST,
  
  422
  >
  		},
  
  423
  >
  	}
  
  424
  >
  }
  
  425
  
  426
  
  // Value sets the string list value of the search attribute.

go.temporal.io/server/service/history/interfaces/shard_context_mock.go 88 covered LOC · 18 ranges

Open complete file

  57
  
  58
  
  // NewMockShardContext creates a new mock instance.
  
  59
  >
  func NewMockShardContext(ctrl *gomock.Controller) *MockShardContext {
  
shard_context_mock.go

  60
  >
  	mock := &MockShardContext{ctrl: ctrl}
  
  61
  >
  	mock.recorder = &MockShardContextMockRecorder{mock}
  
  62
  >
  	return mock
  
  63
  >
  }
  
  64
  
  65
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  66
  >
  func (m *MockShardContext) EXPECT() *MockShardContextMockRecorder {
  
shard_context_mock.go

  67
  >
  	return m.recorder
  
  68
  >
  }
  
  69
  
  70
  
  // AddSpeculativeWorkflowTaskTimeoutTask mocks base method.

  83
  
  84
  
  // AddTasks mocks base method.
  
  85
  >
  func (m *MockShardContext) AddTasks(ctx context.Context, request *persistence0.AddHistoryTasksRequest) error {
  
shard_context_mock.go

  86
  >
  	m.ctrl.T.Helper()
  
  87
  >
  	ret := m.ctrl.Call(m, "AddTasks", ctx, request)
  
  88
  >
  	ret0, _ := ret[0].(error)
  
  89
  >
  	return ret0
  
  90
  >
  }
  
  91
  
  92
  
  // AddTasks indicates an expected call of AddTasks.
  
  93
  >
  func (mr *MockShardContextMockRecorder) AddTasks(ctx, request any) *gomock.Call {
  
shard_context_mock.go

  94
  >
  	mr.mock.ctrl.T.Helper()
  
  95
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockShardContext)(nil).AddTasks), ctx, request)
  
  96
  >
  }
  
  97
  
  98
  
  // AppendHistoryEvents mocks base method.

  140
  
  141
  
  // ChasmRegistry mocks base method.
  
  142
  >
  func (m *MockShardContext) ChasmRegistry() *chasm.Registry {
  
shard_context_mock.go

  143
  >
  	m.ctrl.T.Helper()
  
  144
  >
  	ret := m.ctrl.Call(m, "ChasmRegistry")
  
  145
  >
  	ret0, _ := ret[0].(*chasm.Registry)
  
  146
  >
  	return ret0
  
  147
  >
  }
  
  148
  
  149
  
  // ChasmRegistry indicates an expected call of ChasmRegistry.
  
  150
  >
  func (mr *MockShardContextMockRecorder) ChasmRegistry() *gomock.Call {
  
shard_context_mock.go

  151
  >
  	mr.mock.ctrl.T.Helper()
  
  152
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmRegistry", reflect.TypeOf((*MockShardContext)(nil).ChasmRegistry))
  
  153
  >
  }
  
  154
  
  155
  
  // ChasmWorkflowRegistry mocks base method.

  270
  
  271
  
  // GetArchivalMetadata mocks base method.
  
  272
  >
  func (m *MockShardContext) GetArchivalMetadata() archiver.ArchivalMetadata {
  
shard_context_mock.go

  273
  >
  	m.ctrl.T.Helper()
  
  274
  >
  	ret := m.ctrl.Call(m, "GetArchivalMetadata")
  
  275
  >
  	ret0, _ := ret[0].(archiver.ArchivalMetadata)
  
  276
  >
  	return ret0
  
  277
  >
  }
  
  278
  
  279
  
  // GetArchivalMetadata indicates an expected call of GetArchivalMetadata.
  
  280
  >
  func (mr *MockShardContextMockRecorder) GetArchivalMetadata() *gomock.Call {
  
shard_context_mock.go

  281
  >
  	mr.mock.ctrl.T.Helper()
  
  282
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArchivalMetadata", reflect.TypeOf((*MockShardContext)(nil).GetArchivalMetadata))
  
  283
  >
  }
  
  284
  
  285
  
  // GetCachedWorkflowContext mocks base method.

  300
  
  301
  
  // GetClusterMetadata mocks base method.
  
  302
  >
  func (m *MockShardContext) GetClusterMetadata() cluster.Metadata {
  
shard_context_mock.go

  303
  >
  	m.ctrl.T.Helper()
  
  304
  >
  	ret := m.ctrl.Call(m, "GetClusterMetadata")
  
  305
  >
  	ret0, _ := ret[0].(cluster.Metadata)
  
  306
  >
  	return ret0
  
  307
  >
  }
  
  308
  
  309
  
  // GetClusterMetadata indicates an expected call of GetClusterMetadata.
  
  310
  >
  func (mr *MockShardContextMockRecorder) GetClusterMetadata() *gomock.Call {
  
shard_context_mock.go

  311
  >
  	mr.mock.ctrl.T.Helper()
  
  312
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockShardContext)(nil).GetClusterMetadata))
  
  313
  >
  }
  
  314
  
  315
  
  // GetConfig mocks base method.
  
  316
  >
  func (m *MockShardContext) GetConfig() *configs.Config {
  
shard_context_mock.go

  317
  >
  	m.ctrl.T.Helper()
  
  318
  >
  	ret := m.ctrl.Call(m, "GetConfig")
  
  319
  >
  	ret0, _ := ret[0].(*configs.Config)
  
  320
  >
  	return ret0
  
  321
  >
  }
  
  322
  
  323
  
  // GetConfig indicates an expected call of GetConfig.
  
  324
  >
  func (mr *MockShardContextMockRecorder) GetConfig() *gomock.Call {
  
shard_context_mock.go

  325
  >
  	mr.mock.ctrl.T.Helper()
  
  326
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockShardContext)(nil).GetConfig))
  
  327
  >
  }
  
  328
  
  329
  
  // GetCurrentCachedWorkflowContext mocks base method.

  486
  
  487
  
  // GetLogger mocks base method.
  
  488
  >
  func (m *MockShardContext) GetLogger() log0.Logger {
  
shard_context_mock.go

  489
  >
  	m.ctrl.T.Helper()
  
  490
  >
  	ret := m.ctrl.Call(m, "GetLogger")
  
  491
  >
  	ret0, _ := ret[0].(log0.Logger)
  
  492
  >
  	return ret0
  
  493
  >
  }
  
  494
  
  495
  
  // GetLogger indicates an expected call of GetLogger.
  
  496
  >
  func (mr *MockShardContextMockRecorder) GetLogger() *gomock.Call {
  
shard_context_mock.go

  497
  >
  	mr.mock.ctrl.T.Helper()
  
  498
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogger", reflect.TypeOf((*MockShardContext)(nil).GetLogger))
  
  499
  >
  }
  
  500
  
  501
  
  // GetMetricsHandler mocks base method.

  514
  
  515
  
  // GetNamespaceRegistry mocks base method.
  
  516
  >
  func (m *MockShardContext) GetNamespaceRegistry() namespace.Registry {
  
shard_context_mock.go

  517
  >
  	m.ctrl.T.Helper()
  
  518
  >
  	ret := m.ctrl.Call(m, "GetNamespaceRegistry")
  
  519
  >
  	ret0, _ := ret[0].(namespace.Registry)
  
  520
  >
  	return ret0
  
  521
  >
  }
  
  522
  
  523
  
  // GetNamespaceRegistry indicates an expected call of GetNamespaceRegistry.
  
  524
  >
  func (mr *MockShardContextMockRecorder) GetNamespaceRegistry() *gomock.Call {
  
shard_context_mock.go

  525
  >
  	mr.mock.ctrl.T.Helper()
  
  526
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceRegistry", reflect.TypeOf((*MockShardContext)(nil).GetNamespaceRegistry))
  
  527
  >
  }
  
  528
  
  529
  
  // GetOwner mocks base method.

  672
  
  673
  
  // GetShardID mocks base method.
  
  674
  >
  func (m *MockShardContext) GetShardID() int32 {
  
shard_context_mock.go

  675
  >
  	m.ctrl.T.Helper()
  
  676
  >
  	ret := m.ctrl.Call(m, "GetShardID")
  
  677
  >
  	ret0, _ := ret[0].(int32)
  
  678
  >
  	return ret0
  
  679
  >
  }
  
  680
  
  681
  
  // GetShardID indicates an expected call of GetShardID.
  
  682
  >
  func (mr *MockShardContextMockRecorder) GetShardID() *gomock.Call {
  
shard_context_mock.go

  683
  >
  	mr.mock.ctrl.T.Helper()
  
  684
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardID", reflect.TypeOf((*MockShardContext)(nil).GetShardID))
  
  685
  >
  }
  
  686
  
  687
  
  // GetThrottledLogger mocks base method.

go.temporal.io/server/api/persistence/v1/predicates.pb.go 82 covered LOC · 22 ranges

Open complete file

  57
  
  func (*Predicate) ProtoMessage() {}
  
  58
  
  59
  >
  func (x *Predicate) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  60
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0]
  
  61
  >
  	if x != nil {
  
  62
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  63
  >
  		if ms.LoadMessageInfo() == nil {
  
  64
  >
  			ms.StoreMessageInfo(mi)
  
  65
  >
  		}
  
  66
  >
  		return ms
  
  67
  
  	}
  
  68
  
  	return mi.MessageOf(x)

  261
  
  func (*UniversalPredicateAttributes) ProtoMessage() {}
  
  262
  
  263
  >
  func (x *UniversalPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  264
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[1]
  
  265
  >
  	if x != nil {
  
  266
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  267
  
  		if ms.LoadMessageInfo() == nil {

  270
  
  		return ms
  
  271
  
  	}
  
  272
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  273
  
  }
  
  274

  297
  
  func (*EmptyPredicateAttributes) ProtoMessage() {}
  
  298
  
  299
  >
  func (x *EmptyPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  300
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[2]
  
  301
  >
  	if x != nil {
  
  302
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  303
  
  		if ms.LoadMessageInfo() == nil {

  306
  
  		return ms
  
  307
  
  	}
  
  308
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  309
  
  }
  
  310

  334
  
  func (*AndPredicateAttributes) ProtoMessage() {}
  
  335
  
  336
  >
  func (x *AndPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  337
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[3]
  
  338
  >
  	if x != nil {
  
  339
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  340
  
  		if ms.LoadMessageInfo() == nil {

  343
  
  		return ms
  
  344
  
  	}
  
  345
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  346
  
  }
  
  347

  378
  
  func (*OrPredicateAttributes) ProtoMessage() {}
  
  379
  
  380
  >
  func (x *OrPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  381
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[4]
  
  382
  >
  	if x != nil {
  
  383
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  384
  
  		if ms.LoadMessageInfo() == nil {

  387
  
  		return ms
  
  388
  
  	}
  
  389
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  390
  
  }
  
  391

  422
  
  func (*NotPredicateAttributes) ProtoMessage() {}
  
  423
  
  424
  >
  func (x *NotPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  425
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[5]
  
  426
  >
  	if x != nil {
  
  427
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  428
  
  		if ms.LoadMessageInfo() == nil {

  431
  
  		return ms
  
  432
  
  	}
  
  433
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  434
  
  }
  
  435

  466
  
  func (*NamespaceIdPredicateAttributes) ProtoMessage() {}
  
  467
  
  468
  >
  func (x *NamespaceIdPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  469
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[6]
  
  470
  >
  	if x != nil {
  
  471
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  472
  
  		if ms.LoadMessageInfo() == nil {

  475
  
  		return ms
  
  476
  
  	}
  
  477
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  478
  
  }
  
  479

  510
  
  func (*TaskTypePredicateAttributes) ProtoMessage() {}
  
  511
  
  512
  >
  func (x *TaskTypePredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  513
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[7]
  
  514
  >
  	if x != nil {
  
  515
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  516
  
  		if ms.LoadMessageInfo() == nil {

  519
  
  		return ms
  
  520
  
  	}
  
  521
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  522
  
  }
  
  523

  554
  
  func (*DestinationPredicateAttributes) ProtoMessage() {}
  
  555
  
  556
  >
  func (x *DestinationPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  557
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[8]
  
  558
  >
  	if x != nil {
  
  559
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  560
  
  		if ms.LoadMessageInfo() == nil {

  563
  
  		return ms
  
  564
  
  	}
  
  565
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  566
  
  }
  
  567

  598
  
  func (*OutboundTaskGroupPredicateAttributes) ProtoMessage() {}
  
  599
  
  600
  >
  func (x *OutboundTaskGroupPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  601
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[9]
  
  602
  >
  	if x != nil {
  
  603
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  604
  
  		if ms.LoadMessageInfo() == nil {

  607
  
  		return ms
  
  608
  
  	}
  
  609
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  610
  
  }
  
  611

  642
  
  func (*OutboundTaskPredicateAttributes) ProtoMessage() {}
  
  643
  
  644
  >
  func (x *OutboundTaskPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  645
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[10]
  
  646
  >
  	if x != nil {
  
  647
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  648
  
  		if ms.LoadMessageInfo() == nil {

  651
  
  		return ms
  
  652
  
  	}
  
  653
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  654
  
  }
  
  655

  828
  
  }
  
  829
  
  830
  >
  func init() { file_temporal_server_api_persistence_v1_predicates_proto_init() }
  
predicates.pb.go

  831
  >
  func file_temporal_server_api_persistence_v1_predicates_proto_init() {
  
  832
  >
  	if File_temporal_server_api_persistence_v1_predicates_proto != nil {
  
  833
  >
  		return
  
  834
  >
  	}
  
  835
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0].OneofWrappers = []any{
  
  836
  >
  		(*Predicate_UniversalPredicateAttributes)(nil),
  
  837
  >
  		(*Predicate_EmptyPredicateAttributes)(nil),
  
  838
  >
  		(*Predicate_AndPredicateAttributes)(nil),
  
  839
  >
  		(*Predicate_OrPredicateAttributes)(nil),
  
  840
  >
  		(*Predicate_NotPredicateAttributes)(nil),
  
  841
  >
  		(*Predicate_NamespaceIdPredicateAttributes)(nil),
  
  842
  >
  		(*Predicate_TaskTypePredicateAttributes)(nil),
  
  843
  >
  		(*Predicate_DestinationPredicateAttributes)(nil),
  
  844
  >
  		(*Predicate_OutboundTaskGroupPredicateAttributes)(nil),
  
  845
  >
  		(*Predicate_OutboundTaskPredicateAttributes)(nil),
  
  846
  >
  	}
  
  847
  >
  	type x struct{}
  
  848
  >
  	out := protoimpl.TypeBuilder{
  
  849
  >
  		File: protoimpl.DescBuilder{
  
  850
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  851
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc), len(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc)),
  
  852
  >
  			NumEnums:      0,
  
  853
  >
  			NumMessages:   12,
  
  854
  >
  			NumExtensions: 0,
  
  855
  >
  			NumServices:   0,
  
  856
  >
  		},
  
  857
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_predicates_proto_goTypes,
  
  858
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_predicates_proto_depIdxs,
  
  859
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_predicates_proto_msgTypes,
  
  860
  >
  	}.Build()
  
  861
  >
  	File_temporal_server_api_persistence_v1_predicates_proto = out.File
  
  862
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_goTypes = nil
  
  863
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_depIdxs = nil
  
  864
  
  }

go.temporal.io/server/api/persistence/v1/executions.pb.go 76 covered LOC · 6 ranges

Open complete file

  466
  
  }
  
  467
  
  468
  >
  func (x *WorkflowExecutionInfo) GetWorkflowTypeName() string {
  
executions.pb.go

  469
  >
  	if x != nil {
  
  470
  >
  		return x.WorkflowTypeName
  
  471
  >
  	}
  
  472
  
  	return ""
  
  473
  
  }

  851
  
  }
  
  852
  
  853
  >
  func (x *WorkflowExecutionInfo) GetExecutionTime() *timestamppb.Timestamp {
  
executions.pb.go

  854
  >
  	if x != nil {
  
  855
  >
  		return x.ExecutionTime
  
  856
  >
  	}
  
  857
  
  	return nil
  
  858
  
  }

  900
  
  }
  
  901
  
  902
  >
  func (x *WorkflowExecutionInfo) GetRelocatableAttributesRemoved() bool {
  
executions.pb.go

  903
  >
  	if x != nil {
  
  904
  >
  		return x.RelocatableAttributesRemoved
  
  905
  >
  	}
  
  906
  
  	return false
  
  907
  
  }

  1515
  
  }
  
  1516
  
  1517
  >
  func (x *WorkflowExecutionState) GetStartTime() *timestamppb.Timestamp {
  
executions.pb.go

  1518
  >
  	if x != nil {
  
  1519
  >
  		return x.StartTime
  
executions.pb.go

  1520
  >
  	}
  
  1521
  
  	return nil
  
  1522
  
  }

  5706
  
  }
  
  5707
  
  5708
  >
  func init() { file_temporal_server_api_persistence_v1_executions_proto_init() }
  
executions.pb.go

  5709
  >
  func file_temporal_server_api_persistence_v1_executions_proto_init() {
  
  5710
  >
  	if File_temporal_server_api_persistence_v1_executions_proto != nil {
  
  5711
  >
  		return
  
  5712
  >
  	}
  
  5713
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_init()
  
  5714
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  5715
  >
  	file_temporal_server_api_persistence_v1_queues_proto_init()
  
  5716
  >
  	file_temporal_server_api_persistence_v1_update_proto_init()
  
  5717
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1].OneofWrappers = []any{
  
  5718
  >
  		(*WorkflowExecutionInfo_LastWorkflowTaskFailureCause)(nil),
  
  5719
  >
  		(*WorkflowExecutionInfo_LastWorkflowTaskTimedOutType)(nil),
  
  5720
  >
  	}
  
  5721
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[8].OneofWrappers = []any{
  
  5722
  >
  		(*TransferTaskInfo_CloseExecutionTaskDetails_)(nil),
  
  5723
  >
  		(*TransferTaskInfo_ChasmTaskInfo)(nil),
  
  5724
  >
  	}
  
  5725
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[10].OneofWrappers = []any{
  
  5726
  >
  		(*VisibilityTaskInfo_ChasmTaskInfo)(nil),
  
  5727
  >
  	}
  
  5728
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[11].OneofWrappers = []any{
  
  5729
  >
  		(*TimerTaskInfo_ChasmTaskInfo)(nil),
  
  5730
  >
  	}
  
  5731
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[13].OneofWrappers = []any{
  
  5732
  >
  		(*OutboundTaskInfo_StateMachineInfo)(nil),
  
  5733
  >
  		(*OutboundTaskInfo_ChasmTaskInfo)(nil),
  
  5734
  >
  		(*OutboundTaskInfo_WorkerCommandsTask)(nil),
  
  5735
  >
  	}
  
  5736
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17].OneofWrappers = []any{
  
  5737
  >
  		(*ActivityInfo_UseWorkflowBuildIdInfo_)(nil),
  
  5738
  >
  		(*ActivityInfo_LastIndependentlyAssignedBuildId)(nil),
  
  5739
  >
  	}
  
  5740
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[23].OneofWrappers = []any{
  
  5741
  >
  		(*Callback_Nexus_)(nil),
  
  5742
  >
  		(*Callback_Hsm)(nil),
  
  5743
  >
  	}
  
  5744
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[40].OneofWrappers = []any{
  
  5745
  >
  		(*ActivityInfo_PauseInfo_Manual_)(nil),
  
  5746
  >
  		(*ActivityInfo_PauseInfo_RuleId)(nil),
  
  5747
  >
  	}
  
  5748
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[46].OneofWrappers = []any{
  
  5749
  >
  		(*CallbackInfo_Trigger_WorkflowClosed)(nil),
  
  5750
  >
  	}
  
  5751
  >
  	type x struct{}
  
  5752
  >
  	out := protoimpl.TypeBuilder{
  
  5753
  >
  		File: protoimpl.DescBuilder{
  
  5754
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  5755
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_executions_proto_rawDesc), len(file_temporal_server_api_persistence_v1_executions_proto_rawDesc)),
  
  5756
  >
  			NumEnums:      0,
  
  5757
  >
  			NumMessages:   47,
  
  5758
  >
  			NumExtensions: 0,
  
  5759
  >
  			NumServices:   0,
  
  5760
  >
  		},
  
  5761
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_executions_proto_goTypes,
  
  5762
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_executions_proto_depIdxs,
  
  5763
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_executions_proto_msgTypes,
  
  5764
  >
  	}.Build()
  
  5765
  >
  	File_temporal_server_api_persistence_v1_executions_proto = out.File
  
  5766
  >
  	file_temporal_server_api_persistence_v1_executions_proto_goTypes = nil
  
  5767
  >
  	file_temporal_server_api_persistence_v1_executions_proto_depIdxs = nil
  
  5768
  
  }

go.temporal.io/server/common/log/zap_logger.go 54 covered LOC · 12 ranges

Open complete file

  58
  
  // NewTestLogger returns a logger for tests
  
  59
  
  // Deprecated: Use testlogger.TestLogger instead.
  
  60
  >
  func NewTestLogger() *zapLogger {
  
zap_logger.go

  61
  >
  	format := os.Getenv(TestLogFormatEnvVar)
  
  62
  >
  	if format == "" {
  
  63
  >
  		format = "console"
  
  64
  >
  	}
  
  65
  
  66
  >
  	logger := BuildZapLogger(Config{
  
zap_logger.go

  67
  >
  		Level:       os.Getenv(TestLogLevelEnvVar),
  
  68
  >
  		Format:      format,
  
  69
  >
  		Development: true,
  
  70
  >
  	})
  
  71
  >
  
  72
  >
  	// Don't include stack traces for warnings during tests. Only include them for logs with level error and above.
  
  73
  >
  	logger = logger.WithOptions(zap.AddStacktrace(zap.ErrorLevel))
  
  74
  >
  
  75
  >
  	return NewZapLogger(logger)
  
  76
  
  }
  
  77

  82
  
  83
  
  // NewZapLogger returns a new zap based logger from zap.Logger
  
  84
  >
  func NewZapLogger(zl *zap.Logger) *zapLogger {
  
zap_logger.go

  85
  >
  	return &zapLogger{
  
  86
  >
  		zl:     zl,
  
  87
  >
  		skip:   skipForZapLogger,
  
  88
  >
  		baseZl: zl,
  
  89
  >
  	}
  
  90
  >
  }
  
  91
  
  92
  
  // BuildZapLogger builds and returns a new zap.Logger for this logging configuration
  
  93
  >
  func BuildZapLogger(cfg Config) *zap.Logger {
  
zap_logger.go

  94
  >
  	return buildZapLogger(cfg, true)
  
  95
  >
  }
  
  96
  
  97
  
  func caller(skip int) string {

  234
  
  }
  
  235
  
  236
  >
  func buildZapLogger(cfg Config, disableCaller bool) *zap.Logger {
  
zap_logger.go

  237
  >
  	encodeConfig := DefaultZapEncoderConfig
  
  238
  >
  	if disableCaller {
  
  239
  >
  		encodeConfig.CallerKey = zapcore.OmitKey
  
  240
  >
  		encodeConfig.EncodeCaller = nil
  
  241
  >
  	}
  
  242
  
  243
  >
  	outputPath := "stderr"
  
zap_logger.go

  244
  >
  	if len(cfg.OutputFile) > 0 {
  
  245
  
  		outputPath = cfg.OutputFile
  
  246
  
  	}
  
  247
  >
  	if cfg.Stdout {
  
zap_logger.go

  248
  
  		outputPath = "stdout"
  
  249
  
  	}
  
  250
  >
  	encoding := "json"
  
zap_logger.go

  251
  >
  	if cfg.Format == "console" {
  
  252
  >
  		encoding = "console"
  
zap_logger.go

  253
  >
  	}
  
  254
  >
  	config := zap.Config{
  
zap_logger.go

  255
  >
  		Level:            zap.NewAtomicLevelAt(ParseZapLevel(cfg.Level)),
  
  256
  >
  		Development:      cfg.Development,
  
  257
  >
  		Sampling:         nil,
  
  258
  >
  		Encoding:         encoding,
  
  259
  >
  		EncoderConfig:    encodeConfig,
  
  260
  >
  		OutputPaths:      []string{outputPath},
  
  261
  >
  		ErrorOutputPaths: []string{outputPath},
  
  262
  >
  		DisableCaller:    disableCaller,
  
  263
  >
  	}
  
  264
  >
  	logger, _ := config.Build()
  
  265
  >
  	return logger
  
  266
  
  }
  
  267

  297
  
  }
  
  298
  
  299
  >
  func ParseZapLevel(level string) zapcore.Level {
  
zap_logger.go

  300
  >
  	switch strings.ToLower(level) {
  
  301
  
  	case "debug":
  
  302
  
  		return zap.DebugLevel

  313
  
  	case "fatal":
  
  314
  
  		return zap.FatalLevel
  
  315
  >
  	default:
  
zap_logger.go

  316
  >
  		return zap.InfoLevel
  
  317
  
  	}
  
  318
  
  }

go.temporal.io/server/common/archiver/archival_metadata_mock.go 46 covered LOC · 10 ranges

Open complete file

  30
  
  31
  
  // NewMockArchivalMetadata creates a new mock instance.
  
  32
  >
  func NewMockArchivalMetadata(ctrl *gomock.Controller) *MockArchivalMetadata {
  
archival_metadata_mock.go

  33
  >
  	mock := &MockArchivalMetadata{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockArchivalMetadataMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockArchivalMetadata) EXPECT() *MockArchivalMetadataMockRecorder {
  
archival_metadata_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // GetHistoryConfig mocks base method.
  
  44
  >
  func (m *MockArchivalMetadata) GetHistoryConfig() ArchivalConfig {
  
archival_metadata_mock.go

  45
  >
  	m.ctrl.T.Helper()
  
  46
  >
  	ret := m.ctrl.Call(m, "GetHistoryConfig")
  
  47
  >
  	ret0, _ := ret[0].(ArchivalConfig)
  
  48
  >
  	return ret0
  
  49
  >
  }
  
  50
  
  51
  
  // GetHistoryConfig indicates an expected call of GetHistoryConfig.
  
  52
  >
  func (mr *MockArchivalMetadataMockRecorder) GetHistoryConfig() *gomock.Call {
  
archival_metadata_mock.go

  53
  >
  	mr.mock.ctrl.T.Helper()
  
  54
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryConfig", reflect.TypeOf((*MockArchivalMetadata)(nil).GetHistoryConfig))
  
  55
  >
  }
  
  56
  
  57
  
  // GetVisibilityConfig mocks base method.
  
  58
  >
  func (m *MockArchivalMetadata) GetVisibilityConfig() ArchivalConfig {
  
archival_metadata_mock.go

  59
  >
  	m.ctrl.T.Helper()
  
  60
  >
  	ret := m.ctrl.Call(m, "GetVisibilityConfig")
  
  61
  >
  	ret0, _ := ret[0].(ArchivalConfig)
  
  62
  >
  	return ret0
  
  63
  >
  }
  
  64
  
  65
  
  // GetVisibilityConfig indicates an expected call of GetVisibilityConfig.
  
  66
  >
  func (mr *MockArchivalMetadataMockRecorder) GetVisibilityConfig() *gomock.Call {
  
archival_metadata_mock.go

  67
  >
  	mr.mock.ctrl.T.Helper()
  
  68
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibilityConfig", reflect.TypeOf((*MockArchivalMetadata)(nil).GetVisibilityConfig))
  
  69
  >
  }
  
  70
  
  71
  
  // MockArchivalConfig is a mock of ArchivalConfig interface.

  82
  
  83
  
  // NewMockArchivalConfig creates a new mock instance.
  
  84
  >
  func NewMockArchivalConfig(ctrl *gomock.Controller) *MockArchivalConfig {
  
archival_metadata_mock.go

  85
  >
  	mock := &MockArchivalConfig{ctrl: ctrl}
  
  86
  >
  	mock.recorder = &MockArchivalConfigMockRecorder{mock}
  
  87
  >
  	return mock
  
  88
  >
  }
  
  89
  
  90
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  91
  >
  func (m *MockArchivalConfig) EXPECT() *MockArchivalConfigMockRecorder {
  
archival_metadata_mock.go

  92
  >
  	return m.recorder
  
  93
  >
  }
  
  94
  
  95
  
  // ClusterConfiguredForArchival mocks base method.
  
  96
  >
  func (m *MockArchivalConfig) ClusterConfiguredForArchival() bool {
  
archival_metadata_mock.go

  97
  >
  	m.ctrl.T.Helper()
  
  98
  >
  	ret := m.ctrl.Call(m, "ClusterConfiguredForArchival")
  
  99
  >
  	ret0, _ := ret[0].(bool)
  
  100
  >
  	return ret0
  
  101
  >
  }
  
  102
  
  103
  
  // ClusterConfiguredForArchival indicates an expected call of ClusterConfiguredForArchival.
  
  104
  >
  func (mr *MockArchivalConfigMockRecorder) ClusterConfiguredForArchival() *gomock.Call {
  
archival_metadata_mock.go

  105
  >
  	mr.mock.ctrl.T.Helper()
  
  106
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterConfiguredForArchival", reflect.TypeOf((*MockArchivalConfig)(nil).ClusterConfiguredForArchival))
  
  107
  >
  }
  
  108
  
  109
  
  // GetClusterState mocks base method.

go.temporal.io/server/common/dynamicconfig/collection.go 46 covered LOC · 10 ranges

Open complete file

  111
  
  // NewCollection creates a new collection. For subscriptions to work, you must call Start/Stop.
  
  112
  
  // Get will work without Start/Stop.
  
  113
  >
  func NewCollection(client Client, logger log.Logger) *Collection {
  
collection.go

  114
  >
  	// Do this at the first convenient place we have a logger:
  
  115
  >
  	logSharedStructureWarnings(logger)
  
  116
  >
  
  117
  >
  	return &Collection{
  
  118
  >
  		client:        client,
  
  119
  >
  		logger:        logger,
  
  120
  >
  		errCount:      -1,
  
  121
  >
  		subscriptions: make(map[Key]map[int]any),
  
  122
  >
  		convertCache:  new(sync.Map),
  
  123
  >
  		indexCache:    new(sync.Map),
  
  124
  >
  	}
  
  125
  >
  }
  
  126
  
  127
  
  func (c *Collection) Start() {

  212
  
  	cvs []ConstrainedValue,
  
  213
  
  	precedence []Constraints,
  
  214
  >
  ) (*ConstrainedValue, error) {
  
collection.go

  215
  >
  	if len(cvs) == 0 {
  
  216
  >
  		return nil, errKeyNotPresent
  
collection.go

  217
  >
  	} else if len(cvs) > constraintsCacheThreshold && len(cvs) <= math.MaxInt32 {
  
collection.go

  218
  
  		return findMatchWithCache(cache, cvs, precedence)
  
  219
  
  	}

  279
  
  	convert func(value any) (T, error),
  
  280
  
  	precedence []Constraints,
  
  281
  >
  ) T {
  
collection.go

  282
  >
  	cvs := c.client.GetValue(key)
  
  283
  >
  	v, _ := matchAndConvertCvs(c, key, def, convert, precedence, cvs)
  
  284
  >
  	return v
  
  285
  >
  }
  
  286
  
  287
  
  func matchAndConvertCvs[T any](

  292
  
  	precedence []Constraints,
  
  293
  
  	cvs []ConstrainedValue,
  
  294
  >
  ) (T, any) {
  
collection.go

  295
  >
  	cvp, err := findMatch(c.indexCache, cvs, precedence)
  
  296
  >
  	if err != nil {
  
  297
  >
  		// couldn't find a constrained match, use default
  
collection.go

  298
  >
  		return def, usingDefaultValue
  
  299
  >
  	}
  
  300
  
  301
  
  	typedVal, err := convertWithCache(c, key, convert, cvp)

  676
  
  // treat the fields independently), or the zero value of its type (if you want to treat the fields
  
  677
  
  // as a group and default unset fields to zero).
  
  678
  >
  func ConvertStructure[T any](def T) func(v any) (T, error) {
  
collection.go

  679
  >
  	return func(v any) (T, error) {
  
  680
  >
  		// if we already have the right type, no conversion is necessary
  
  681
  >
  		if typedV, ok := v.(T); ok {
  
  682
  
  			return typedV, nil
  
  683
  
  		}

  685
  
  		// Deep-copy the default and decode over it. This allows using e.g. a struct with some
  
  686
  
  		// default fields filled in and a config that only set some fields.
  
  687
  >
  		out := deepCopyForMapstructure(def)
  
collection.go

  688
  >
  
  689
  >
  		dec, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
  
  690
  >
  			Result: &out,
  
  691
  >
  			DecodeHook: mapstructure.ComposeDecodeHookFunc(
  
  692
  >
  				mapstructureHookDuration,
  
  693
  >
  				mapstructureHookTimestamp,
  
  694
  >
  				mapstructureHookProtoEnum,
  
  695
  >
  				mapstructureHookGeneric,
  
  696
  >
  			),
  
  697
  >
  		})
  
  698
  >
  		if err != nil {
  
  699
  
  			return out, err
  
  700
  
  		}
  
  701
  >
  		err = dec.Decode(v)
  
collection.go

  702
  >
  		return out, err
  
  703
  
  	}
  
  704
  
  }

go.temporal.io/server/api/historyservice/v1/request_response.pb.go 45 covered LOC · 1 range

Open complete file

  11956
  
  }
  
  11957
  
  11958
  >
  func init() { file_temporal_server_api_historyservice_v1_request_response_proto_init() }
  
request_response.pb.go

  11959
  >
  func file_temporal_server_api_historyservice_v1_request_response_proto_init() {
  
  11960
  >
  	if File_temporal_server_api_historyservice_v1_request_response_proto != nil {
  
  11961
  >
  		return
  
  11962
  >
  	}
  
  11963
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[107].OneofWrappers = []any{
  
  11964
  >
  		(*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),
  
  11965
  >
  	}
  
  11966
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[108].OneofWrappers = []any{
  
  11967
  >
  		(*StreamWorkflowReplicationMessagesResponse_Messages)(nil),
  
  11968
  >
  	}
  
  11969
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[134].OneofWrappers = []any{
  
  11970
  >
  		(*CompleteNexusOperationChasmRequest_Success)(nil),
  
  11971
  >
  		(*CompleteNexusOperationChasmRequest_Failure)(nil),
  
  11972
  >
  	}
  
  11973
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[136].OneofWrappers = []any{
  
  11974
  >
  		(*CompleteNexusOperationRequest_Success)(nil),
  
  11975
  >
  		(*CompleteNexusOperationRequest_Failure)(nil),
  
  11976
  >
  	}
  
  11977
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[162].OneofWrappers = []any{
  
  11978
  >
  		(*ExecuteMultiOperationRequest_Operation_StartWorkflow)(nil),
  
  11979
  >
  		(*ExecuteMultiOperationRequest_Operation_UpdateWorkflow)(nil),
  
  11980
  >
  	}
  
  11981
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[163].OneofWrappers = []any{
  
  11982
  >
  		(*ExecuteMultiOperationResponse_Response_StartWorkflow)(nil),
  
  11983
  >
  		(*ExecuteMultiOperationResponse_Response_UpdateWorkflow)(nil),
  
  11984
  >
  	}
  
  11985
  >
  	type x struct{}
  
  11986
  >
  	out := protoimpl.TypeBuilder{
  
  11987
  >
  		File: protoimpl.DescBuilder{
  
  11988
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  11989
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc)),
  
  11990
  >
  			NumEnums:      0,
  
  11991
  >
  			NumMessages:   171,
  
  11992
  >
  			NumExtensions: 1,
  
  11993
  >
  			NumServices:   0,
  
  11994
  >
  		},
  
  11995
  >
  		GoTypes:           file_temporal_server_api_historyservice_v1_request_response_proto_goTypes,
  
  11996
  >
  		DependencyIndexes: file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs,
  
  11997
  >
  		MessageInfos:      file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes,
  
  11998
  >
  		ExtensionInfos:    file_temporal_server_api_historyservice_v1_request_response_proto_extTypes,
  
  11999
  >
  	}.Build()
  
  12000
  >
  	File_temporal_server_api_historyservice_v1_request_response_proto = out.File
  
  12001
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_goTypes = nil
  
  12002
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs = nil
  
  12003
  
  }

go.temporal.io/server/common/namespace/namespace.go 44 covered LOC · 13 ranges

Open complete file

  81
  
  	resolver ReplicationResolver,
  
  82
  
  	mutations ...Mutation,
  
  83
  >
  ) (*Namespace, error) {
  
namespace.go

  84
  >
  	if resolver == nil {
  
  85
  
  		return nil, serviceerror.NewInvalidArgument("replicationResolver must be provided")
  
  86
  
  	}
  
  87
  >
  	ns := &Namespace{
  
namespace.go

  88
  >
  		info:          detail.Info,
  
  89
  >
  		config:        detail.Config,
  
  90
  >
  		configVersion: detail.ConfigVersion,
  
  91
  >
  		customSearchAttributesMapper: CustomSearchAttributesMapper{
  
  92
  >
  			fieldToAlias: detail.Config.CustomSearchAttributeAliases,
  
  93
  >
  			aliasToField: util.InverseMap(detail.Config.CustomSearchAttributeAliases),
  
  94
  >
  		},
  
  95
  >
  		replicationResolver: resolver,
  
  96
  >
  	}
  
  97
  >
  
  98
  >
  	for _, m := range mutations {
  
  99
  >
  		m.apply(ns)
  
namespace.go

  100
  >
  	}
  
  101
  
  102
  >
  	return ns, nil
  
namespace.go

  103
  
  }
  
  104

  128
  
  // VisibilityArchivalState observes the visibility archive configuration (state
  
  129
  
  // and URI) for this namespace.
  
  130
  >
  func (ns *Namespace) VisibilityArchivalState() ArchivalConfigState {
  
namespace.go

  131
  >
  	return ArchivalConfigState{
  
  132
  >
  		State: ns.config.VisibilityArchivalState,
  
  133
  >
  		URI:   ns.config.VisibilityArchivalUri,
  
  134
  >
  	}
  
  135
  >
  }
  
  136
  
  137
  
  // HistoryArchivalState observes the history archive configuration (state and
  
  138
  
  // URI) for this namespace.
  
  139
  >
  func (ns *Namespace) HistoryArchivalState() ArchivalConfigState {
  
namespace.go

  140
  >
  	return ArchivalConfigState{
  
  141
  >
  		State: ns.config.HistoryArchivalState,
  
  142
  >
  		URI:   ns.config.HistoryArchivalUri,
  
  143
  >
  	}
  
  144
  >
  }
  
  145
  
  146
  
  // VerifyBinaryChecksum returns an error if the provided checksum is one of this

  159
  
  160
  
  // ID observes this namespace's permanent unique identifier in string form.
  
  161
  >
  func (ns *Namespace) ID() ID {
  
namespace.go

  162
  >
  	if ns.info == nil {
  
  163
  
  		return ID("")
  
  164
  
  	}
  
  165
  >
  	return ID(ns.info.Id)
  
namespace.go

  166
  
  }
  
  167
  
  168
  
  // Name observes this namespace's configured name.
  
  169
  >
  func (ns *Namespace) Name() Name {
  
namespace.go

  170
  >
  	if ns.info == nil {
  
  171
  
  		return Name("")
  
  172
  
  	}
  
  173
  >
  	return Name(ns.info.Name)
  
namespace.go

  174
  
  }
  
  175

  219
  
  // Being a global namespace doesn't necessarily mean that there are multiple registered clusters for it, only that it
  
  220
  
  // has a failover version. To determine whether operations should be replicated for a namespace, see ReplicationPolicy.
  
  221
  >
  func (ns *Namespace) IsGlobalNamespace() bool {
  
namespace.go

  222
  >
  	return ns.replicationResolver.IsGlobalNamespace()
  
  223
  >
  }
  
  224
  
  225
  
  // FailoverNotificationVersion return the global notification version of when failover happened

  337
  
  }
  
  338
  
  339
  >
  func (id ID) String() string {
  
namespace.go

  340
  >
  	return string(id)
  
  341
  >
  }
  
  342
  
  343
  
  func (id ID) IsEmpty() bool {

  345
  
  }
  
  346
  
  347
  >
  func (n Name) String() string {
  
namespace.go

  348
  >
  	return string(n)
  
  349
  >
  }
  
  350
  
  351
  
  func (n Name) IsEmpty() bool {

go.temporal.io/server/api/matchingservice/v1/request_response.pb.go 43 covered LOC · 1 range

Open complete file

  6833
  
  }
  
  6834
  
  6835
  >
  func init() { file_temporal_server_api_matchingservice_v1_request_response_proto_init() }
  
request_response.pb.go

  6836
  >
  func file_temporal_server_api_matchingservice_v1_request_response_proto_init() {
  
  6837
  >
  	if File_temporal_server_api_matchingservice_v1_request_response_proto != nil {
  
  6838
  >
  		return
  
  6839
  >
  	}
  
  6840
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[27].OneofWrappers = []any{
  
  6841
  >
  		(*UpdateWorkerBuildIdCompatibilityRequest_ApplyPublicRequest_)(nil),
  
  6842
  >
  		(*UpdateWorkerBuildIdCompatibilityRequest_RemoveBuildIds_)(nil),
  
  6843
  >
  		(*UpdateWorkerBuildIdCompatibilityRequest_PersistUnknownBuildId)(nil),
  
  6844
  >
  	}
  
  6845
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[29].OneofWrappers = []any{
  
  6846
  >
  		(*GetWorkerVersioningRulesRequest_Request)(nil),
  
  6847
  >
  	}
  
  6848
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[31].OneofWrappers = []any{
  
  6849
  >
  		(*UpdateWorkerVersioningRulesRequest_Request)(nil),
  
  6850
  >
  	}
  
  6851
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[37].OneofWrappers = []any{
  
  6852
  >
  		(*SyncDeploymentUserDataRequest_UpdateVersionData)(nil),
  
  6853
  >
  		(*SyncDeploymentUserDataRequest_ForgetVersion)(nil),
  
  6854
  >
  	}
  
  6855
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[56].OneofWrappers = []any{
  
  6856
  >
  		(*DispatchNexusTaskResponse_HandlerError)(nil),
  
  6857
  >
  		(*DispatchNexusTaskResponse_Response)(nil),
  
  6858
  >
  		(*DispatchNexusTaskResponse_RequestTimeout)(nil),
  
  6859
  >
  		(*DispatchNexusTaskResponse_Failure)(nil),
  
  6860
  >
  	}
  
  6861
  >
  	type x struct{}
  
  6862
  >
  	out := protoimpl.TypeBuilder{
  
  6863
  >
  		File: protoimpl.DescBuilder{
  
  6864
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  6865
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_request_response_proto_rawDesc)),
  
  6866
  >
  			NumEnums:      0,
  
  6867
  >
  			NumMessages:   97,
  
  6868
  >
  			NumExtensions: 0,
  
  6869
  >
  			NumServices:   0,
  
  6870
  >
  		},
  
  6871
  >
  		GoTypes:           file_temporal_server_api_matchingservice_v1_request_response_proto_goTypes,
  
  6872
  >
  		DependencyIndexes: file_temporal_server_api_matchingservice_v1_request_response_proto_depIdxs,
  
  6873
  >
  		MessageInfos:      file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes,
  
  6874
  >
  	}.Build()
  
  6875
  >
  	File_temporal_server_api_matchingservice_v1_request_response_proto = out.File
  
  6876
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_goTypes = nil
  
  6877
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_depIdxs = nil
  
  6878
  
  }

go.temporal.io/server/common/log/tag/tags.go 42 covered LOC · 14 ranges

Open complete file

  70
  
  71
  
  // WorkflowAction returns tag for WorkflowAction
  
  72
  >
  func workflowAction(action string) ZapTag {
  
tags.go

  73
  >
  	return NewStringTag("wf-action", action)
  
  74
  >
  }
  
  75
  
  76
  
  // WorkflowListFilterType returns tag for WorkflowListFilterType
  
  77
  >
  func workflowListFilterType(listFilterType string) ZapTag {
  
tags.go

  78
  >
  	return NewStringTag("wf-list-filter-type", listFilterType)
  
  79
  >
  }
  
  80
  
  81
  
  // general

  108
  
  // WorkflowID returns tag for WorkflowID
  
  109
  
  // TODO: Rename to BusinessID.
  
  110
  >
  func WorkflowID(workflowID string) ZapTag {
  
tags.go

  111
  >
  	return NewStringTag(WorkflowIDKey, workflowID)
  
  112
  >
  }
  
  113
  
  114
  
  // WorkflowType returns tag for WorkflowType

  124
  
  // WorkflowRunID returns tag for WorkflowRunID
  
  125
  
  // TODO: Rename to RunID
  
  126
  >
  func WorkflowRunID(runID string) ZapTag {
  
tags.go

  127
  >
  	return NewStringTag(WorkflowRunIDKey, runID)
  
  128
  >
  }
  
  129
  
  130
  
  // WorkflowNewRunID returns tag for WorkflowNewRunID

  187
  
  // WorkflowNamespaceID returns tag for WorkflowNamespaceID
  
  188
  
  // TODO: Rename to NamespaceID
  
  189
  >
  func WorkflowNamespaceID(namespaceID string) ZapTag {
  
tags.go

  190
  >
  	return NewStringTag("wf-namespace-id", namespaceID)
  
  191
  >
  }
  
  192
  
  193
  
  // WorkflowNamespace returns tag for WorkflowNamespace

  376
  
  377
  
  // Component returns tag for Component
  
  378
  >
  func component(component string) ZapTag {
  
tags.go

  379
  >
  	return NewStringTag("component", component)
  
  380
  >
  }
  
  381
  
  382
  
  // Lifecycle returns tag for Lifecycle
  
  383
  >
  func lifecycle(lifecycle string) ZapTag {
  
tags.go

  384
  >
  	return NewStringTag("lifecycle", lifecycle)
  
  385
  >
  }
  
  386
  
  387
  
  // StoreOperation returns tag for StoreOperation
  
  388
  >
  func storeOperation(storeOperation string) ZapTag {
  
tags.go

  389
  >
  	return NewStringTag("store-operation", storeOperation)
  
  390
  >
  }
  
  391
  
  392
  
  // OperationResult returns tag for OperationResult
  
  393
  >
  func operationResult(operationResult string) ZapTag {
  
tags.go

  394
  >
  	return NewStringTag("operation-result", operationResult)
  
  395
  >
  }
  
  396
  
  397
  
  // ErrorType returns tag for ErrorType

  401
  
  402
  
  // errorType returns tag for ErrorType given a string
  
  403
  >
  func errorType(errorType string) ZapTag {
  
tags.go

  404
  >
  	return NewStringTag("error-type", errorType)
  
  405
  >
  }
  
  406
  
  407
  
  // Shardupdate returns tag for Shardupdate
  
  408
  >
  func shardupdate(shardupdate string) ZapTag {
  
tags.go

  409
  >
  	return NewStringTag("shard-update", shardupdate)
  
  410
  >
  }
  
  411
  
  412
  
  // scope returns a tag for scope
  
  413
  
  // Pre-defined scope tags are in values.go.
  
  414
  >
  func scope(scope string) ZapTag {
  
tags.go

  415
  >
  	return NewStringTag("scope", scope)
  
  416
  >
  }
  
  417
  
  418
  
  // general

  615
  
  616
  
  // Task returns tag for Task
  
  617
  >
  func Task(task any) ZapTag {
  
tags.go

  618
  >
  	return NewAnyTag("queue-task", task)
  
  619
  >
  }
  
  620
  
  621
  
  // TaskID returns tag for TaskID

  630
  
  631
  
  // TaskVersion returns tag for TaskVersion
  
  632
  >
  func TaskVersion(taskVersion int64) ZapTag {
  
tags.go

  633
  >
  	return NewInt64("queue-task-version", taskVersion)
  
  634
  >
  }
  
  635
  
  636
  
  func TaskType(taskType enumsspb.TaskType) ZapTag {

go.temporal.io/server/common/metrics/defs.go 41 covered LOC · 7 ranges

Open complete file

  20
  
  )
  
  21
  
  22
  >
  func NewTimerDef(name string, opts ...Option) timerDefinition {
  
defs.go

  23
  >
  	// This line cannot be combined with others!
  
  24
  >
  	// This ensures the stack trace has information of the caller.
  
  25
  >
  	def := newMetricDefinition(name, opts...)
  
  26
  >
  	globalRegistry.register(def)
  
  27
  >
  	return timerDefinition{def}
  
  28
  >
  }
  
  29
  
  30
  >
  func NewBytesHistogramDef(name string, opts ...Option) histogramDefinition {
  
defs.go

  31
  >
  	// This line cannot be combined with others!
  
  32
  >
  	// This ensures the stack trace has information of the caller.
  
  33
  >
  	def := newMetricDefinition(name, append(opts, WithUnit(Bytes))...)
  
  34
  >
  	globalRegistry.register(def)
  
  35
  >
  	return histogramDefinition{def}
  
  36
  >
  }
  
  37
  
  38
  >
  func NewDimensionlessHistogramDef(name string, opts ...Option) histogramDefinition {
  
defs.go

  39
  >
  	// This line cannot be combined with others!
  
  40
  >
  	// This ensures the stack trace has information of the caller.
  
  41
  >
  	def := newMetricDefinition(name, append(opts, WithUnit(Dimensionless))...)
  
  42
  >
  	globalRegistry.register(def)
  
  43
  >
  	return histogramDefinition{def}
  
  44
  >
  }
  
  45
  
  46
  >
  func NewCounterDef(name string, opts ...Option) counterDefinition {
  
defs.go

  47
  >
  	// This line cannot be combined with others!
  
  48
  >
  	// This ensures the stack trace has information of the caller.
  
  49
  >
  	def := newMetricDefinition(name, opts...)
  
  50
  >
  	globalRegistry.register(def)
  
  51
  >
  	return counterDefinition{def}
  
  52
  >
  }
  
  53
  
  54
  >
  func NewGaugeDef(name string, opts ...Option) gaugeDefinition {
  
defs.go

  55
  >
  	// This line cannot be combined with others!
  
  56
  >
  	// This ensures the stack trace has information of the caller.
  
  57
  >
  	def := newMetricDefinition(name, opts...)
  
  58
  >
  	globalRegistry.register(def)
  
  59
  >
  	return gaugeDefinition{def}
  
  60
  >
  }
  
  61
  
  62
  
  func (d histogramDefinition) With(handler Handler) HistogramIface {

  64
  
  }
  
  65
  
  66
  >
  func (d counterDefinition) With(handler Handler) CounterIface {
  
defs.go

  67
  >
  	return handler.Counter(d.name)
  
  68
  >
  }
  
  69
  
  70
  
  func (d gaugeDefinition) With(handler Handler) GaugeIface {

  72
  
  }
  
  73
  
  74
  >
  func (d timerDefinition) With(handler Handler) TimerIface {
  
defs.go

  75
  >
  	return handler.Timer(d.name)
  
  76
  >
  }

go.temporal.io/server/common/backoff/retrypolicy.go 38 covered LOC · 7 ranges

Open complete file

  80
  
  81
  
  // NewExponentialRetryPolicy returns an instance of ExponentialRetryPolicy using the provided initialInterval
  
  82
  >
  func NewExponentialRetryPolicy(initialInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  83
  >
  	p := &ExponentialRetryPolicy{
  
  84
  >
  		initialInterval:    initialInterval,
  
  85
  >
  		backoffCoefficient: defaultBackoffCoefficient,
  
  86
  >
  		maximumInterval:    defaultMaximumInterval,
  
  87
  >
  		expirationInterval: defaultExpirationInterval,
  
  88
  >
  		maximumAttempts:    defaultMaximumAttempts,
  
  89
  >
  	}
  
  90
  >
  
  91
  >
  	return p
  
  92
  >
  }
  
  93
  
  94
  
  // NewRetrier is used for creating a new instance of Retrier

  113
  
  // All retries are computed using the following formula:
  
  114
  
  // initialInterval * math.Pow(backoffCoefficient, currentAttempt)
  
  115
  >
  func (p *ExponentialRetryPolicy) WithBackoffCoefficient(backoffCoefficient float64) *ExponentialRetryPolicy {
  
retrypolicy.go

  116
  >
  	p.backoffCoefficient = backoffCoefficient
  
  117
  >
  	return p
  
  118
  >
  }
  
  119
  
  120
  
  // WithMaximumInterval sets the maximum interval for each retry.
  
  121
  
  // This does *not* cause the policy to stop retrying when the interval between retries reaches the supplied duration.
  
  122
  
  // That is what WithExpirationInterval does. Instead, this prevents the interval from exceeding maximumInterval.
  
  123
  >
  func (p *ExponentialRetryPolicy) WithMaximumInterval(maximumInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  124
  >
  	p.maximumInterval = maximumInterval
  
  125
  >
  	return p
  
  126
  >
  }
  
  127
  
  128
  
  // WithExpirationInterval sets the absolute expiration interval for all retries
  
  129
  >
  func (p *ExponentialRetryPolicy) WithExpirationInterval(expirationInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  130
  >
  	p.expirationInterval = expirationInterval
  
  131
  >
  	return p
  
  132
  >
  }
  
  133
  
  134
  
  // WithMaximumAttempts sets the maximum number of retry attempts
  
  135
  >
  func (p *ExponentialRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ExponentialRetryPolicy {
  
retrypolicy.go

  136
  >
  	p.maximumAttempts = maximumAttempts
  
  137
  >
  	return p
  
  138
  >
  }
  
  139
  
  140
  
  // ComputeNextDelay returns the next delay interval.  This is used by Retrier to delay calling the operation again

  267
  
  var _ RetryPolicy = (*ConstantDelayRetryPolicy)(nil)
  
  268
  
  269
  >
  func NewConstantDelayRetryPolicy(delay time.Duration) *ConstantDelayRetryPolicy {
  
retrypolicy.go

  270
  >
  	return &ConstantDelayRetryPolicy{
  
  271
  >
  		maximumAttempts: defaultMaximumAttempts,
  
  272
  >
  		jitterPct:       defaultJitterPct,
  
  273
  >
  		delay:           delay,
  
  274
  >
  	}
  
  275
  >
  }
  
  276
  
  277
  >
  func (p *ConstantDelayRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ConstantDelayRetryPolicy {
  
retrypolicy.go

  278
  >
  	p.maximumAttempts = maximumAttempts
  
  279
  >
  	return p
  
  280
  >
  }
  
  281
  
  282
  
  func (p *ConstantDelayRetryPolicy) WithJitter(jitterPct float64) *ConstantDelayRetryPolicy {

go.temporal.io/server/api/adminservice/v1/request_response.pb.go 36 covered LOC · 1 range

Open complete file

  6623
  
  }
  
  6624
  
  6625
  >
  func init() { file_temporal_server_api_adminservice_v1_request_response_proto_init() }
  
request_response.pb.go

  6626
  >
  func file_temporal_server_api_adminservice_v1_request_response_proto_init() {
  
  6627
  >
  	if File_temporal_server_api_adminservice_v1_request_response_proto != nil {
  
  6628
  >
  		return
  
  6629
  >
  	}
  
  6630
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[59].OneofWrappers = []any{
  
  6631
  >
  		(*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),
  
  6632
  >
  	}
  
  6633
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[60].OneofWrappers = []any{
  
  6634
  >
  		(*StreamWorkflowReplicationMessagesResponse_Messages)(nil),
  
  6635
  >
  	}
  
  6636
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[61].OneofWrappers = []any{
  
  6637
  >
  		(*GetNamespaceRequest_Namespace)(nil),
  
  6638
  >
  		(*GetNamespaceRequest_Id)(nil),
  
  6639
  >
  	}
  
  6640
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[90].OneofWrappers = []any{
  
  6641
  >
  		(*StartAdminBatchOperationRequest_RefreshTasksOperation)(nil),
  
  6642
  >
  	}
  
  6643
  >
  	type x struct{}
  
  6644
  >
  	out := protoimpl.TypeBuilder{
  
  6645
  >
  		File: protoimpl.DescBuilder{
  
  6646
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  6647
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc)),
  
  6648
  >
  			NumEnums:      1,
  
  6649
  >
  			NumMessages:   105,
  
  6650
  >
  			NumExtensions: 0,
  
  6651
  >
  			NumServices:   0,
  
  6652
  >
  		},
  
  6653
  >
  		GoTypes:           file_temporal_server_api_adminservice_v1_request_response_proto_goTypes,
  
  6654
  >
  		DependencyIndexes: file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs,
  
  6655
  >
  		EnumInfos:         file_temporal_server_api_adminservice_v1_request_response_proto_enumTypes,
  
  6656
  >
  		MessageInfos:      file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes,
  
  6657
  >
  	}.Build()
  
  6658
  >
  	File_temporal_server_api_adminservice_v1_request_response_proto = out.File
  
  6659
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_goTypes = nil
  
  6660
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs = nil
  
  6661
  
  }

go.temporal.io/server/api/replication/v1/message.pb.go 36 covered LOC · 2 ranges

Open complete file

  2441
  
  }
  
  2442
  
  2443
  >
  func init() { file_temporal_server_api_replication_v1_message_proto_init() }
  
message.pb.go

  2444
  >
  func file_temporal_server_api_replication_v1_message_proto_init() {
  
  2445
  >
  	if File_temporal_server_api_replication_v1_message_proto != nil {
  
  2446
  
  		return
  
  2447
  
  	}
  
  2448
  >
  	file_temporal_server_api_replication_v1_message_proto_msgTypes[0].OneofWrappers = []any{
  
message.pb.go

  2449
  >
  		(*ReplicationTask_NamespaceTaskAttributes)(nil),
  
  2450
  >
  		(*ReplicationTask_SyncShardStatusTaskAttributes)(nil),
  
  2451
  >
  		(*ReplicationTask_SyncActivityTaskAttributes)(nil),
  
  2452
  >
  		(*ReplicationTask_HistoryTaskAttributes)(nil),
  
  2453
  >
  		(*ReplicationTask_SyncWorkflowStateTaskAttributes)(nil),
  
  2454
  >
  		(*ReplicationTask_TaskQueueUserDataAttributes)(nil),
  
  2455
  >
  		(*ReplicationTask_SyncHsmAttributes)(nil),
  
  2456
  >
  		(*ReplicationTask_BackfillHistoryTaskAttributes)(nil),
  
  2457
  >
  		(*ReplicationTask_VerifyVersionedTransitionTaskAttributes)(nil),
  
  2458
  >
  		(*ReplicationTask_SyncVersionedTransitionTaskAttributes)(nil),
  
  2459
  >
  	}
  
  2460
  >
  	file_temporal_server_api_replication_v1_message_proto_msgTypes[21].OneofWrappers = []any{
  
  2461
  >
  		(*VersionedTransitionArtifact_SyncWorkflowStateMutationAttributes)(nil),
  
  2462
  >
  		(*VersionedTransitionArtifact_SyncWorkflowStateSnapshotAttributes)(nil),
  
  2463
  >
  	}
  
  2464
  >
  	type x struct{}
  
  2465
  >
  	out := protoimpl.TypeBuilder{
  
  2466
  >
  		File: protoimpl.DescBuilder{
  
  2467
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  2468
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_replication_v1_message_proto_rawDesc), len(file_temporal_server_api_replication_v1_message_proto_rawDesc)),
  
  2469
  >
  			NumEnums:      0,
  
  2470
  >
  			NumMessages:   23,
  
  2471
  >
  			NumExtensions: 0,
  
  2472
  >
  			NumServices:   0,
  
  2473
  >
  		},
  
  2474
  >
  		GoTypes:           file_temporal_server_api_replication_v1_message_proto_goTypes,
  
  2475
  >
  		DependencyIndexes: file_temporal_server_api_replication_v1_message_proto_depIdxs,
  
  2476
  >
  		MessageInfos:      file_temporal_server_api_replication_v1_message_proto_msgTypes,
  
  2477
  >
  	}.Build()
  
  2478
  >
  	File_temporal_server_api_replication_v1_message_proto = out.File
  
  2479
  >
  	file_temporal_server_api_replication_v1_message_proto_goTypes = nil
  
  2480
  >
  	file_temporal_server_api_replication_v1_message_proto_depIdxs = nil
  
  2481
  
  }

go.temporal.io/server/common/namespace/testconstructors.go 36 covered LOC · 8 ranges

Open complete file

  13
  
  	config *persistencespb.NamespaceConfig,
  
  14
  
  	targetCluster string,
  
  15
  >
  ) *Namespace {
  
testconstructors.go

  16
  >
  	detail := &persistencespb.NamespaceDetail{
  
  17
  >
  		Info:   ensureInfo(info),
  
  18
  >
  		Config: ensureConfig(config),
  
  19
  >
  		ReplicationConfig: &persistencespb.NamespaceReplicationConfig{
  
  20
  >
  			ActiveClusterName: targetCluster,
  
  21
  >
  			Clusters:          []string{targetCluster},
  
  22
  >
  		},
  
  23
  >
  		FailoverVersion: common.EmptyVersion,
  
  24
  >
  	}
  
  25
  >
  	factory := NewDefaultReplicationResolverFactory()
  
  26
  >
  	resolver := factory(detail)
  
  27
  >
  	ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(false))
  
  28
  >
  	return ns
  
  29
  >
  }
  
  30
  
  31
  
  // NewNamespaceForTest returns an entry with test data

  55
  
  	repConfig *persistencespb.NamespaceReplicationConfig,
  
  56
  
  	failoverVersion int64,
  
  57
  >
  ) *Namespace {
  
testconstructors.go

  58
  >
  	detail := &persistencespb.NamespaceDetail{
  
  59
  >
  		Info:              ensureInfo(info),
  
  60
  >
  		Config:            ensureConfig(config),
  
  61
  >
  		ReplicationConfig: ensureRepConfig(repConfig),
  
  62
  >
  		FailoverVersion:   failoverVersion,
  
  63
  >
  	}
  
  64
  >
  	factory := NewDefaultReplicationResolverFactory()
  
  65
  >
  	resolver := factory(detail)
  
  66
  >
  	ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(true))
  
  67
  >
  	return ns
  
  68
  >
  }
  
  69
  
  70
  >
  func ensureInfo(proto *persistencespb.NamespaceInfo) *persistencespb.NamespaceInfo {
  
testconstructors.go

  71
  >
  	if proto == nil {
  
  72
  
  		return &persistencespb.NamespaceInfo{}
  
  73
  
  	}
  
  74
  >
  	return proto
  
testconstructors.go

  75
  
  }
  
  76
  
  77
  >
  func ensureConfig(proto *persistencespb.NamespaceConfig) *persistencespb.NamespaceConfig {
  
testconstructors.go

  78
  >
  	if proto == nil {
  
  79
  
  		return &persistencespb.NamespaceConfig{}
  
  80
  
  	}
  
  81
  >
  	return proto
  
testconstructors.go

  82
  
  }
  
  83
  
  84
  >
  func ensureRepConfig(proto *persistencespb.NamespaceReplicationConfig) *persistencespb.NamespaceReplicationConfig {
  
testconstructors.go

  85
  >
  	if proto == nil {
  
  86
  
  		return &persistencespb.NamespaceReplicationConfig{}
  
  87
  
  	}
  
  88
  >
  	return proto
  
testconstructors.go

  89
  
  }

go.temporal.io/server/service/history/statemachine_environment.go 36 covered LOC · 7 ranges

Open complete file

  25
  
  )
  
  26
  
  27
  >
  func taskWorkflowKey(task tasks.Task) definition.WorkflowKey {
  
statemachine_environment.go

  28
  >
  	return definition.NewWorkflowKey(task.GetNamespaceID(), task.GetWorkflowID(), task.GetRunID())
  
  29
  >
  }
  
  30
  
  31
  >
  func getTaskArchetypeID(task tasks.Task) chasm.ArchetypeID {
  
statemachine_environment.go

  32
  >
  	archetypeID := chasm.WorkflowArchetypeID
  
  33
  >
  	if hasArchetypeID, ok := task.(tasks.HasArchetypeID); ok {
  
  34
  
  		archetypeID = hasArchetypeID.GetArchetypeID()
  
  35

  40
  
  	}
  
  41
  
  42
  >
  	return archetypeID
  
statemachine_environment.go

  43
  
  }
  
  44

  48
  
  	workflowCache wcache.Cache,
  
  49
  
  	task tasks.Task,
  
  50
  >
  ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) {
  
statemachine_environment.go

  51
  >
  	return getWorkflowExecutionContext(
  
  52
  >
  		ctx,
  
  53
  >
  		shardContext,
  
  54
  >
  		workflowCache,
  
  55
  >
  		taskWorkflowKey(task),
  
  56
  >
  		getTaskArchetypeID(task),
  
  57
  >
  		locks.PriorityLow,
  
  58
  >
  	)
  
  59
  >
  }
  
  60
  
  61
  
  func getWorkflowExecutionContext(

  66
  
  	archetypeID chasm.ArchetypeID,
  
  67
  
  	lockPriority locks.Priority,
  
  68
  >
  ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) {
  
statemachine_environment.go

  69
  >
  	if key.GetRunID() == "" {
  
  70
  
  		return getCurrentWorkflowExecutionContext(
  
  71
  
  			ctx,

  79
  
  	}
  
  80
  
  81
  >
  	namespaceID := namespace.ID(key.GetNamespaceID())
  
statemachine_environment.go

  82
  >
  	execution := &commonpb.WorkflowExecution{
  
  83
  >
  		WorkflowId: key.GetWorkflowID(),
  
  84
  >
  		RunId:      key.GetRunID(),
  
  85
  >
  	}
  
  86
  >
  	// workflowCache will automatically use short context timeout when
  
  87
  >
  	// locking workflow for all background calls, we don't need a separate context here
  
  88
  >
  	weContext, release, err := workflowCache.GetOrCreateChasmExecution(
  
  89
  >
  		ctx,
  
  90
  >
  		shardContext,
  
  91
  >
  		namespaceID,
  
  92
  >
  		execution,
  
  93
  >
  		archetypeID,
  
  94
  >
  		lockPriority,
  
  95
  >
  	)
  
  96
  >
  	if common.IsContextDeadlineExceededErr(err) {
  
  97
  
  		// TODO: make sure this doesn't count against our SLA if this happens while handling an API request.
  
  98
  
  		err = consts.ErrResourceExhaustedBusyWorkflow
  
  99
  
  	}
  
  100
  >
  	return weContext, release, err
  
statemachine_environment.go

  101
  
  }
  
  102

go.temporal.io/server/service/history/workflow/task_generator.go 34 covered LOC · 8 ranges

Open complete file

  115
  
  	archivalMetadata archiver.ArchivalMetadata,
  
  116
  
  	logger log.Logger,
  
  117
  >
  ) *TaskGeneratorImpl {
  
task_generator.go

  118
  >
  	return &TaskGeneratorImpl{
  
  119
  >
  		namespaceRegistry: namespaceRegistry,
  
  120
  >
  		mutableState:      mutableState,
  
  121
  >
  		config:            config,
  
  122
  >
  		archivalMetadata:  archivalMetadata,
  
  123
  >
  		logger:            logger,
  
  124
  >
  	}
  
  125
  >
  }
  
  126
  
  127
  
  func (r *TaskGeneratorImpl) GenerateWorkflowStartTasks(

  278
  
  // This method returns an error when the GetNamespaceByID call fails with anything other than
  
  279
  
  // serviceerror.NamespaceNotFound.
  
  280
  >
  func (r *TaskGeneratorImpl) getRetention() (time.Duration, error) {
  
task_generator.go

  281
  >
  	retention := defaultWorkflowRetention
  
  282
  >
  	executionInfo := r.mutableState.GetExecutionInfo()
  
  283
  >
  	namespaceEntry, err := r.namespaceRegistry.GetNamespaceByID(namespace.ID(executionInfo.NamespaceId))
  
  284
  >
  	switch err.(type) {
  
  285
  
  	case nil:
  
  286
  
  		retention = namespaceEntry.Retention()
  
  287
  >
  	case *serviceerror.NamespaceNotFound:
  
task_generator.go

  288
  
  		// namespace is not accessible, use default value above
  
  289
  
  	default:
  
  290
  
  		return 0, err
  
  291
  
  	}
  
  292
  >
  	return retention, nil
  
task_generator.go

  293
  
  }
  
  294

  337
  
  // This method only adds the task to the mutable state object in memory; it does not write the task to the database.
  
  338
  
  // You must call shard.Context#AddTasks to notify the history engine of this task.
  
  339
  >
  func (r *TaskGeneratorImpl) GenerateDeleteHistoryEventTask(closeTime time.Time) error {
  
task_generator.go

  340
  >
  	retention, err := r.getRetention()
  
  341
  >
  	if err != nil {
  
  342
  
  		return err
  
  343
  
  	}
  
  344
  >
  	closeVersion, err := r.mutableState.GetCloseVersion()
  
task_generator.go

  345
  >
  	if err != nil {
  
  346
  
  		return err
  
  347
  
  	}
  
  348
  
  349
  >
  	branchToken, err := r.mutableState.GetCurrentBranchToken()
  
task_generator.go

  350
  >
  	if err != nil {
  
  351
  
  		return err
  
  352
  
  	}
  
  353
  
  354
  >
  	retentionJitterDuration := backoff.FullJitter(r.config.RetentionTimerJitterDuration())
  
task_generator.go

  355
  >
  	deleteTime := closeTime.Add(retention).Add(retentionJitterDuration)
  
  356
  >
  	r.mutableState.AddTasks(&tasks.DeleteHistoryEventTask{
  
  357
  >
  		// TaskID is set by shard
  
  358
  >
  		WorkflowKey:         r.mutableState.GetWorkflowKey(),
  
  359
  >
  		VisibilityTimestamp: deleteTime,
  
  360
  >
  		Version:             closeVersion,
  
  361
  >
  		BranchToken:         branchToken,
  
  362
  >
  		ArchetypeID:         r.mutableState.ChasmTree().ArchetypeID(),
  
  363
  >
  	})
  
  364
  >
  	return nil
  
  365
  
  }
  
  366

go.temporal.io/server/api/persistence/v1/chasm.pb.go 33 covered LOC · 1 range

Open complete file

  1180
  
  }
  
  1181
  
  1182
  >
  func init() { file_temporal_server_api_persistence_v1_chasm_proto_init() }
  
chasm.pb.go

  1183
  >
  func file_temporal_server_api_persistence_v1_chasm_proto_init() {
  
  1184
  >
  	if File_temporal_server_api_persistence_v1_chasm_proto != nil {
  
  1185
  >
  		return
  
  1186
  >
  	}
  
  1187
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  1188
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[1].OneofWrappers = []any{
  
  1189
  >
  		(*ChasmNodeMetadata_ComponentAttributes)(nil),
  
  1190
  >
  		(*ChasmNodeMetadata_DataAttributes)(nil),
  
  1191
  >
  		(*ChasmNodeMetadata_CollectionAttributes)(nil),
  
  1192
  >
  		(*ChasmNodeMetadata_PointerAttributes)(nil),
  
  1193
  >
  	}
  
  1194
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[10].OneofWrappers = []any{
  
  1195
  >
  		(*ChasmNexusCompletion_Success)(nil),
  
  1196
  >
  		(*ChasmNexusCompletion_Failure)(nil),
  
  1197
  >
  	}
  
  1198
  >
  	type x struct{}
  
  1199
  >
  	out := protoimpl.TypeBuilder{
  
  1200
  >
  		File: protoimpl.DescBuilder{
  
  1201
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1202
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc)),
  
  1203
  >
  			NumEnums:      0,
  
  1204
  >
  			NumMessages:   15,
  
  1205
  >
  			NumExtensions: 0,
  
  1206
  >
  			NumServices:   0,
  
  1207
  >
  		},
  
  1208
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_chasm_proto_goTypes,
  
  1209
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_proto_depIdxs,
  
  1210
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_chasm_proto_msgTypes,
  
  1211
  >
  	}.Build()
  
  1212
  >
  	File_temporal_server_api_persistence_v1_chasm_proto = out.File
  
  1213
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_goTypes = nil
  
  1214
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_depIdxs = nil
  
  1215
  
  }

go.temporal.io/server/common/util.go 33 covered LOC · 6 ranges

Open complete file

  161
  
  162
  
  // CreatePersistenceClientRetryPolicy creates a retry policy for calls to persistence
  
  163
  >
  func CreatePersistenceClientRetryPolicy() backoff.RetryPolicy {
  
util.go

  164
  >
  	return backoff.NewExponentialRetryPolicy(persistenceClientRetryInitialInterval).
  
  165
  >
  		WithMaximumAttempts(persistenceClientRetryMaxAttempts)
  
  166
  >
  }
  
  167
  
  168
  
  // CreateFrontendClientRetryPolicy creates a retry policy for calls to frontend service

  249
  
  250
  
  // CreateTaskReschedulePolicy creates a retry policy for rescheduling task with errors not equal to ErrTaskRetry
  
  251
  >
  func CreateTaskReschedulePolicy() backoff.RetryPolicy {
  
util.go

  252
  >
  	return backoff.NewExponentialRetryPolicy(taskRescheduleInitialInterval).
  
  253
  >
  		WithBackoffCoefficient(taskRescheduleBackoffCoefficient).
  
  254
  >
  		WithMaximumInterval(taskRescheduleMaxInterval).
  
  255
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  256
  >
  }
  
  257
  
  258
  
  // CreateDependencyTaskNotCompletedReschedulePolicy creates a retry policy for rescheduling task with
  
  259
  
  // ErrDependencyTaskNotCompleted
  
  260
  >
  func CreateDependencyTaskNotCompletedReschedulePolicy() backoff.RetryPolicy {
  
util.go

  261
  >
  	return backoff.NewExponentialRetryPolicy(dependencyTaskNotCompletedRescheduleInitialInterval).
  
  262
  >
  		WithBackoffCoefficient(dependencyTaskNotCompletedRescheduleBackoffCoefficient).
  
  263
  >
  		WithMaximumInterval(dependencyTaskNotCompletedRescheduleMaxInterval).
  
  264
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  265
  >
  }
  
  266
  
  267
  
  // CreateTaskNotReadyReschedulePolicy creates a retry policy for rescheduling task with ErrTaskRetry
  
  268
  >
  func CreateTaskNotReadyReschedulePolicy() backoff.RetryPolicy {
  
util.go

  269
  >
  	return backoff.NewExponentialRetryPolicy(taskNotReadyRescheduleInitialInterval).
  
  270
  >
  		WithBackoffCoefficient(taskNotReadyRescheduleBackoffCoefficient).
  
  271
  >
  		WithMaximumInterval(taskNotReadyRescheduleMaxInterval).
  
  272
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  273
  >
  }
  
  274
  
  275
  
  // CreateTaskResourceExhaustedReschedulePolicy creates a retry policy for rescheduling task with resource exhausted error
  
  276
  >
  func CreateTaskResourceExhaustedReschedulePolicy() backoff.RetryPolicy {
  
util.go

  277
  >
  	return backoff.NewExponentialRetryPolicy(taskResourceExhaustedRescheduleInitialInterval).
  
  278
  >
  		WithBackoffCoefficient(taskResourceExhaustedRescheduleBackoffCoefficient).
  
  279
  >
  		WithMaximumInterval(taskResourceExhaustedRescheduleMaxInterval).
  
  280
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  281
  >
  }
  
  282
  
  283
  
  // CreateSdkClientFactoryRetryPolicy creates a retry policy to handle SdkClientFactory NewClient when frontend service is not ready

  322
  
  323
  
  // IsContextDeadlineExceededErr checks if the error is context.DeadlineExceeded or serviceerror.DeadlineExceeded error
  
  324
  >
  func IsContextDeadlineExceededErr(err error) bool {
  
util.go

  325
  >
  	var deadlineExceededSvcErr *serviceerror.DeadlineExceeded
  
  326
  >
  	return errors.Is(err, context.DeadlineExceeded) ||
  
  327
  >
  		errors.As(err, &deadlineExceededSvcErr)
  
  328
  >
  }
  
  329
  
  330
  
  // IsContextCanceledErr checks if the error is context.Canceled or serviceerror.Canceled error

go.temporal.io/server/api/persistence/v1/hsm.pb.go 32 covered LOC · 1 range

Open complete file

  895
  
  }
  
  896
  
  897
  >
  func init() { file_temporal_server_api_persistence_v1_hsm_proto_init() }
  
hsm.pb.go

  898
  >
  func file_temporal_server_api_persistence_v1_hsm_proto_init() {
  
  899
  >
  	if File_temporal_server_api_persistence_v1_hsm_proto != nil {
  
  900
  >
  		return
  
  901
  >
  	}
  
  902
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[8].OneofWrappers = []any{
  
  903
  >
  		(*StateMachineTombstone_ActivityScheduledEventId)(nil),
  
  904
  >
  		(*StateMachineTombstone_TimerId)(nil),
  
  905
  >
  		(*StateMachineTombstone_ChildExecutionInitiatedEventId)(nil),
  
  906
  >
  		(*StateMachineTombstone_RequestCancelInitiatedEventId)(nil),
  
  907
  >
  		(*StateMachineTombstone_SignalExternalInitiatedEventId)(nil),
  
  908
  >
  		(*StateMachineTombstone_UpdateId)(nil),
  
  909
  >
  		(*StateMachineTombstone_StateMachinePath)(nil),
  
  910
  >
  		(*StateMachineTombstone_ChasmNodePath)(nil),
  
  911
  >
  	}
  
  912
  >
  	type x struct{}
  
  913
  >
  	out := protoimpl.TypeBuilder{
  
  914
  >
  		File: protoimpl.DescBuilder{
  
  915
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  916
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc)),
  
  917
  >
  			NumEnums:      0,
  
  918
  >
  			NumMessages:   12,
  
  919
  >
  			NumExtensions: 0,
  
  920
  >
  			NumServices:   0,
  
  921
  >
  		},
  
  922
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_hsm_proto_goTypes,
  
  923
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_hsm_proto_depIdxs,
  
  924
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_hsm_proto_msgTypes,
  
  925
  >
  	}.Build()
  
  926
  >
  	File_temporal_server_api_persistence_v1_hsm_proto = out.File
  
  927
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_goTypes = nil
  
  928
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_depIdxs = nil
  
  929
  
  }

go.temporal.io/server/api/persistence/v1/update.pb.go 31 covered LOC · 1 range

Open complete file

  422
  
  }
  
  423
  
  424
  >
  func init() { file_temporal_server_api_persistence_v1_update_proto_init() }
  
update.pb.go

  425
  >
  func file_temporal_server_api_persistence_v1_update_proto_init() {
  
  426
  >
  	if File_temporal_server_api_persistence_v1_update_proto != nil {
  
  427
  >
  		return
  
  428
  >
  	}
  
  429
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  430
  >
  	file_temporal_server_api_persistence_v1_update_proto_msgTypes[0].OneofWrappers = []any{
  
  431
  >
  		(*UpdateAdmissionInfo_HistoryPointer_)(nil),
  
  432
  >
  	}
  
  433
  >
  	file_temporal_server_api_persistence_v1_update_proto_msgTypes[3].OneofWrappers = []any{
  
  434
  >
  		(*UpdateInfo_Acceptance)(nil),
  
  435
  >
  		(*UpdateInfo_Completion)(nil),
  
  436
  >
  		(*UpdateInfo_Admission)(nil),
  
  437
  >
  	}
  
  438
  >
  	type x struct{}
  
  439
  >
  	out := protoimpl.TypeBuilder{
  
  440
  >
  		File: protoimpl.DescBuilder{
  
  441
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  442
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_update_proto_rawDesc), len(file_temporal_server_api_persistence_v1_update_proto_rawDesc)),
  
  443
  >
  			NumEnums:      0,
  
  444
  >
  			NumMessages:   5,
  
  445
  >
  			NumExtensions: 0,
  
  446
  >
  			NumServices:   0,
  
  447
  >
  		},
  
  448
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_update_proto_goTypes,
  
  449
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_update_proto_depIdxs,
  
  450
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_update_proto_msgTypes,
  
  451
  >
  	}.Build()
  
  452
  >
  	File_temporal_server_api_persistence_v1_update_proto = out.File
  
  453
  >
  	file_temporal_server_api_persistence_v1_update_proto_goTypes = nil
  
  454
  >
  	file_temporal_server_api_persistence_v1_update_proto_depIdxs = nil
  
  455
  
  }

go.temporal.io/server/common/dynamicconfig/deepcopy.go 31 covered LOC · 6 ranges

Open complete file

  9
  
  // deepCopyForMapstructure does a simple deep copy of T. Fancy cases (anything other than plain old data)
  
  10
  
  // is not handled and will panic.
  
  11
  >
  func deepCopyForMapstructure[T any](t T) T {
  
deepcopy.go

  12
  >
  	// nolint:revive // this will be triggered from a static initializer before it can be triggered from production code
  
  13
  >
  	return deepCopyValue(reflect.ValueOf(t)).Interface().(T)
  
  14
  >
  }
  
  15
  
  16
  >
  func deepCopyValue(v reflect.Value) reflect.Value {
  
deepcopy.go

  17
  >
  	switch v.Kind() {
  
  18
  
  	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
  
  19
  
  		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
  
  20
  >
  		reflect.Uintptr, reflect.Float32, reflect.Float64, reflect.String:
  
deepcopy.go

  21
  >
  		nv := reflect.New(v.Type()).Elem()
  
  22
  >
  		nv.Set(v)
  
  23
  >
  		return nv
  
  24
  
  	case reflect.Array:
  
  25
  
  		nv := reflect.New(v.Type()).Elem()

  42
  
  		}
  
  43
  
  		return deepCopyValue(v.Elem()).Addr()
  
  44
  >
  	case reflect.Slice:
  
deepcopy.go

  45
  >
  		if v.IsNil() {
  
  46
  >
  			return v
  
  47
  >
  		}
  
  48
  
  		nv := reflect.MakeSlice(v.Type(), v.Len(), v.Len())
  
  49
  
  		for i := range v.Len() {

  51
  
  		}
  
  52
  
  		return nv
  
  53
  >
  	case reflect.Struct:
  
deepcopy.go

  54
  >
  		// Special case for time.Time: it has unexported fields so we can't copy it field by
  
  55
  >
  		// field, but we can copy zero values (which is all we need for default values).
  
  56
  >
  		if v.Type() == reflect.TypeFor[time.Time]() {
  
  57
  >
  			if v.Interface().(time.Time).IsZero() {
  
  58
  >
  				return reflect.ValueOf(time.Time{})
  
  59
  >
  			}
  
  60
  
  			// nolint:forbidigo // this will be triggered from a static initializer before it can be triggered from production code
  
  61
  
  			panic(fmt.Sprintf("Can't deep copy non-zero time.Time: %v", v.Interface()))
  
  62
  
  		}
  
  63
  >
  		nv := reflect.New(v.Type()).Elem()
  
deepcopy.go

  64
  >
  		for i := range v.Type().NumField() {
  
  65
  >
  			nv.Field(i).Set(deepCopyValue(v.Field(i)))
  
  66
  >
  		}
  
  67
  >
  		return nv
  
  68
  >
  	case reflect.Interface, reflect.Func, reflect.Chan:
  
  69
  >
  		// only nil values of any other reference types allowed!
  
  70
  >
  		if v.IsNil() {
  
  71
  >
  			return v
  
  72
  >
  		}
  
  73
  
  		fallthrough
  
  74
  
  	default:

go.temporal.io/server/common/namespace/registry_mock.go 30 covered LOC · 6 ranges

Open complete file

  30
  
  31
  
  // NewMockRegistry creates a new mock instance.
  
  32
  >
  func NewMockRegistry(ctrl *gomock.Controller) *MockRegistry {
  
registry_mock.go

  33
  >
  	mock := &MockRegistry{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockRegistryMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockRegistry) EXPECT() *MockRegistryMockRecorder {
  
registry_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // GetAllNamespaces mocks base method.

  86
  
  87
  
  // GetNamespaceByID mocks base method.
  
  88
  >
  func (m *MockRegistry) GetNamespaceByID(id ID) (*Namespace, error) {
  
registry_mock.go

  89
  >
  	m.ctrl.T.Helper()
  
  90
  >
  	ret := m.ctrl.Call(m, "GetNamespaceByID", id)
  
  91
  >
  	ret0, _ := ret[0].(*Namespace)
  
  92
  >
  	ret1, _ := ret[1].(error)
  
  93
  >
  	return ret0, ret1
  
  94
  >
  }
  
  95
  
  96
  
  // GetNamespaceByID indicates an expected call of GetNamespaceByID.
  
  97
  >
  func (mr *MockRegistryMockRecorder) GetNamespaceByID(id any) *gomock.Call {
  
registry_mock.go

  98
  >
  	mr.mock.ctrl.T.Helper()
  
  99
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceByID", reflect.TypeOf((*MockRegistry)(nil).GetNamespaceByID), id)
  
  100
  >
  }
  
  101
  
  102
  
  // GetNamespaceByIDWithOptions mocks base method.

  131
  
  132
  
  // GetNamespaceName mocks base method.
  
  133
  >
  func (m *MockRegistry) GetNamespaceName(id ID) (Name, error) {
  
registry_mock.go

  134
  >
  	m.ctrl.T.Helper()
  
  135
  >
  	ret := m.ctrl.Call(m, "GetNamespaceName", id)
  
  136
  >
  	ret0, _ := ret[0].(Name)
  
  137
  >
  	ret1, _ := ret[1].(error)
  
  138
  >
  	return ret0, ret1
  
  139
  >
  }
  
  140
  
  141
  
  // GetNamespaceName indicates an expected call of GetNamespaceName.
  
  142
  >
  func (mr *MockRegistryMockRecorder) GetNamespaceName(id any) *gomock.Call {
  
registry_mock.go

  143
  >
  	mr.mock.ctrl.T.Helper()
  
  144
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceName", reflect.TypeOf((*MockRegistry)(nil).GetNamespaceName), id)
  
  145
  >
  }
  
  146
  
  147
  
  // GetNamespaceWithOptions mocks base method.

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

  53
  
  )
  
  54
  
  55
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  56
  >
  	b := make([]string, len(a))
  
  57
  >
  	for i, v := range a {
  
  58
  >
  		b[i] = f(v)
  
  59
  >
  	}
  
  60
  >
  	return b
  
  61
  
  }
  
  62
  
  63
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  64
  >
  	return fmt.Sprintf(deleteMapQryTemplate, tableName)
  
  65
  >
  }
  
  66
  
  67
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  68
  >
  	return fmt.Sprintf(setKeyInMapQryTemplate,
  
  69
  >
  		tableName,
  
  70
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  71
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  72
  >
  			return ":" + x
  
  73
  >
  		}), ","),
  
  74
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  75
  >
  			return x + "=VALUES(" + x + ")"
  
  76
  >
  		}), ","),
  
  77
  
  		mapKeyName)
  
  78
  
  }
  
  79
  
  80
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  81
  >
  	return fmt.Sprintf(deleteKeyInMapQryTemplate,
  
  82
  >
  		tableName,
  
  83
  >
  		mapKeyName)
  
  84
  >
  }
  
  85
  
  86
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  87
  >
  	return fmt.Sprintf(getMapQryTemplate,
  
  88
  >
  		tableName,
  
  89
  >
  		mapKeyName,
  
  90
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  91
  >
  }
  
  92
  
  93
  
  var (

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/execution_maps.go 30 covered LOC · 6 ranges

Open complete file

  86
  
  )
  
  87
  
  88
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  89
  >
  	b := make([]string, len(a))
  
  90
  >
  	for i, v := range a {
  
  91
  >
  		b[i] = f(v)
  
  92
  >
  	}
  
  93
  >
  	return b
  
  94
  
  }
  
  95
  
  96
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  97
  >
  	return fmt.Sprintf(deleteMapQueryTemplate, tableName)
  
  98
  >
  }
  
  99
  
  100
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  101
  >
  	return fmt.Sprintf(setKeyInMapQueryTemplate,
  
  102
  >
  		tableName,
  
  103
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  104
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  105
  >
  			return ":" + x
  
  106
  >
  		}), ","),
  
  107
  
  		mapKeyName,
  
  108
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
execution_maps.go

  109
  >
  			return "excluded." + x
  
  110
  >
  		}), ","))
  
  111
  
  }
  
  112
  
  113
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  114
  >
  	return fmt.Sprintf(deleteKeyInMapQueryTemplate,
  
  115
  >
  		tableName,
  
  116
  >
  		mapKeyName)
  
  117
  >
  }
  
  118
  
  119
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  120
  >
  	return fmt.Sprintf(getMapQueryTemplate,
  
  121
  >
  		tableName,
  
  122
  >
  		mapKeyName,
  
  123
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  124
  >
  }
  
  125
  
  126
  
  var (

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

  52
  
  )
  
  53
  
  54
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  55
  >
  	b := make([]string, len(a))
  
  56
  >
  	for i, v := range a {
  
  57
  >
  		b[i] = f(v)
  
  58
  >
  	}
  
  59
  >
  	return b
  
  60
  
  }
  
  61
  
  62
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  63
  >
  	return fmt.Sprintf(deleteMapQryTemplate, tableName)
  
  64
  >
  }
  
  65
  
  66
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  67
  >
  	return fmt.Sprintf(setKeyInMapQryTemplate,
  
  68
  >
  		tableName,
  
  69
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  70
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  71
  >
  			return ":" + x
  
  72
  >
  		}), ","),
  
  73
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  74
  >
  			return x + "=" + x
  
  75
  >
  		}), ","),
  
  76
  
  		mapKeyName)
  
  77
  
  }
  
  78
  
  79
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  80
  >
  	return fmt.Sprintf(deleteKeyInMapQryTemplate,
  
  81
  >
  		tableName,
  
  82
  >
  		mapKeyName)
  
  83
  >
  }
  
  84
  
  85
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  86
  >
  	return fmt.Sprintf(getMapQryTemplate,
  
  87
  >
  		tableName,
  
  88
  >
  		mapKeyName,
  
  89
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  90
  >
  }
  
  91
  
  92
  
  var (

go.temporal.io/server/common/searchattribute/sadefs/constants.go 30 covered LOC · 9 ranges

Open complete file

  261
  
  	}
  
  262
  
  263
  >
  	dbCustomSearchAttributeFieldNameRE = func() map[enumspb.IndexedValueType]*regexp.Regexp {
  
constants.go

  264
  >
  		res := map[enumspb.IndexedValueType]*regexp.Regexp{}
  
  265
  >
  		for t := range defaultNumDBCustomSearchAttributes {
  
  266
  >
  			res[t] = regexp.MustCompile(fmt.Sprintf(`^%s(0[1-9]|[1-9][0-9])$`, t.String()))
  
  267
  >
  		}
  
  268
  >
  		return res
  
  269
  
  	}()
  
  270
  
  )
  
  271
  
  272
  
  // System returns a clone of the system search attributes map.
  
  273
  >
  func System() map[string]enumspb.IndexedValueType {
  
constants.go

  274
  >
  	return maps.Clone(system)
  
  275
  >
  }
  
  276
  
  277
  
  // Predefined returns a clone of the predefined search attributes map.
  
  278
  >
  func Predefined() map[string]enumspb.IndexedValueType {
  
constants.go

  279
  >
  	return maps.Clone(predefined)
  
  280
  >
  }
  
  281
  
  282
  
  // PredefinedWhiteList returns a clone of the predefined whitelist search attributes map.
  
  283
  >
  func PredefinedWhiteList() map[string]enumspb.IndexedValueType {
  
constants.go

  284
  >
  	return maps.Clone(predefinedWhiteList)
  
  285
  >
  }
  
  286
  
  287
  
  // Reserved returns a clone of the reserved field names map.

  343
  
  // GetSqlDbColName maps system and reserved search attributes to column names for SQL tables.
  
  344
  
  // If the input is not a system or reserved search attribute, then it returns the input.
  
  345
  >
  func GetSqlDbColName(name string) string {
  
constants.go

  346
  >
  	if fieldName, ok := sqlDbSystemNameToColName[name]; ok {
  
  347
  >
  		return fieldName
  
constants.go

  348
  >
  	}
  
  349
  
  	return name
  
  350
  
  }

  352
  
  func GetDBIndexSearchAttributes(
  
  353
  
  	override map[enumspb.IndexedValueType]int,
  
  354
  >
  ) *persistencespb.IndexSearchAttributes {
  
constants.go

  355
  >
  	csa := map[string]enumspb.IndexedValueType{}
  
  356
  >
  	for saType, defaultNumAttrs := range defaultNumDBCustomSearchAttributes {
  
  357
  >
  		numAttrs := defaultNumAttrs
  
  358
  >
  		if value, ok := override[saType]; ok {
  
  359
  
  			numAttrs = value
  
  360
  
  		}
  
  361
  >
  		for i := range numAttrs {
  
constants.go

  362
  >
  			csa[fmt.Sprintf("%s%02d", saType.String(), i+1)] = saType
  
  363
  >
  		}
  
  364
  
  	}
  
  365
  >
  	return &persistencespb.IndexSearchAttributes{
  
constants.go

  366
  >
  		CustomSearchAttributes: csa,
  
  367
  >
  	}
  
  368
  
  }
  
  369

go.temporal.io/server/api/taskqueue/v1/message.pb.go 29 covered LOC · 2 ranges

Open complete file

  1330
  
  }
  
  1331
  
  1332
  >
  func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() }
  
message.pb.go

  1333
  >
  func file_temporal_server_api_taskqueue_v1_message_proto_init() {
  
  1334
  >
  	if File_temporal_server_api_taskqueue_v1_message_proto != nil {
  
  1335
  
  		return
  
  1336
  
  	}
  
  1337
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{
  
message.pb.go

  1338
  >
  		(*TaskVersionDirective_UseAssignmentRules)(nil),
  
  1339
  >
  		(*TaskVersionDirective_AssignedBuildId)(nil),
  
  1340
  >
  	}
  
  1341
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{
  
  1342
  >
  		(*TaskQueuePartition_NormalPartitionId)(nil),
  
  1343
  >
  		(*TaskQueuePartition_StickyName)(nil),
  
  1344
  >
  		(*TaskQueuePartition_WorkerCommands)(nil),
  
  1345
  >
  	}
  
  1346
  >
  	type x struct{}
  
  1347
  >
  	out := protoimpl.TypeBuilder{
  
  1348
  >
  		File: protoimpl.DescBuilder{
  
  1349
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1350
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),
  
  1351
  >
  			NumEnums:      0,
  
  1352
  >
  			NumMessages:   16,
  
  1353
  >
  			NumExtensions: 0,
  
  1354
  >
  			NumServices:   0,
  
  1355
  >
  		},
  
  1356
  >
  		GoTypes:           file_temporal_server_api_taskqueue_v1_message_proto_goTypes,
  
  1357
  >
  		DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,
  
  1358
  >
  		MessageInfos:      file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,
  
  1359
  >
  	}.Build()
  
  1360
  >
  	File_temporal_server_api_taskqueue_v1_message_proto = out.File
  
  1361
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil
  
  1362
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil
  
  1363
  
  }

go.temporal.io/server/common/cluster/metadata_mock.go 28 covered LOC · 6 ranges

Open complete file

  30
  
  31
  
  // NewMockMetadata creates a new mock instance.
  
  32
  >
  func NewMockMetadata(ctrl *gomock.Controller) *MockMetadata {
  
metadata_mock.go

  33
  >
  	mock := &MockMetadata{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockMetadataMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockMetadata) EXPECT() *MockMetadataMockRecorder {
  
metadata_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // ClusterNameForFailoverVersion mocks base method.

  84
  
  85
  
  // GetCurrentClusterName mocks base method.
  
  86
  >
  func (m *MockMetadata) GetCurrentClusterName() string {
  
metadata_mock.go

  87
  >
  	m.ctrl.T.Helper()
  
  88
  >
  	ret := m.ctrl.Call(m, "GetCurrentClusterName")
  
  89
  >
  	ret0, _ := ret[0].(string)
  
  90
  >
  	return ret0
  
  91
  >
  }
  
  92
  
  93
  
  // GetCurrentClusterName indicates an expected call of GetCurrentClusterName.
  
  94
  >
  func (mr *MockMetadataMockRecorder) GetCurrentClusterName() *gomock.Call {
  
metadata_mock.go

  95
  >
  	mr.mock.ctrl.T.Helper()
  
  96
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterName", reflect.TypeOf((*MockMetadata)(nil).GetCurrentClusterName))
  
  97
  >
  }
  
  98
  
  99
  
  // GetFailoverVersionIncrement mocks base method.

  154
  
  155
  
  // IsGlobalNamespaceEnabled mocks base method.
  
  156
  >
  func (m *MockMetadata) IsGlobalNamespaceEnabled() bool {
  
metadata_mock.go

  157
  >
  	m.ctrl.T.Helper()
  
  158
  >
  	ret := m.ctrl.Call(m, "IsGlobalNamespaceEnabled")
  
  159
  >
  	ret0, _ := ret[0].(bool)
  
  160
  >
  	return ret0
  
  161
  >
  }
  
  162
  
  163
  
  // IsGlobalNamespaceEnabled indicates an expected call of IsGlobalNamespaceEnabled.
  
  164
  >
  func (mr *MockMetadataMockRecorder) IsGlobalNamespaceEnabled() *gomock.Call {
  
metadata_mock.go

  165
  >
  	mr.mock.ctrl.T.Helper()
  
  166
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGlobalNamespaceEnabled", reflect.TypeOf((*MockMetadata)(nil).IsGlobalNamespaceEnabled))
  
  167
  >
  }
  
  168
  
  169
  
  // IsMasterCluster mocks base method.

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/message.pb.go 26 covered LOC · 1 range

Open complete file

  843
  
  }
  
  844
  
  845
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() }
  
message.pb.go

  846
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() {
  
  847
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto != nil {
  
  848
  >
  		return
  
  849
  >
  	}
  
  850
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes[4].OneofWrappers = []any{
  
  851
  >
  		(*BackfillerState_BackfillRequest)(nil),
  
  852
  >
  		(*BackfillerState_TriggerRequest)(nil),
  
  853
  >
  	}
  
  854
  >
  	type x struct{}
  
  855
  >
  	out := protoimpl.TypeBuilder{
  
  856
  >
  		File: protoimpl.DescBuilder{
  
  857
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  858
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc)),
  
  859
  >
  			NumEnums:      0,
  
  860
  >
  			NumMessages:   12,
  
  861
  >
  			NumExtensions: 0,
  
  862
  >
  			NumServices:   0,
  
  863
  >
  		},
  
  864
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes,
  
  865
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs,
  
  866
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes,
  
  867
  >
  	}.Build()
  
  868
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto = out.File
  
  869
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes = nil
  
  870
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs = nil
  
  871
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go 25 covered LOC · 2 ranges

Open complete file

  1382
  
  }
  
  1383
  
  1384
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() }
  
activity_state.pb.go

  1385
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() {
  
  1386
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto != nil {
  
  1387
  
  		return
  
  1388
  
  	}
  
  1389
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes[7].OneofWrappers = []any{
  
activity_state.pb.go

  1390
  >
  		(*ActivityOutcome_Successful_)(nil),
  
  1391
  >
  		(*ActivityOutcome_Failed_)(nil),
  
  1392
  >
  	}
  
  1393
  >
  	type x struct{}
  
  1394
  >
  	out := protoimpl.TypeBuilder{
  
  1395
  >
  		File: protoimpl.DescBuilder{
  
  1396
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1397
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc)),
  
  1398
  >
  			NumEnums:      2,
  
  1399
  >
  			NumMessages:   11,
  
  1400
  >
  			NumExtensions: 0,
  
  1401
  >
  			NumServices:   0,
  
  1402
  >
  		},
  
  1403
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes,
  
  1404
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs,
  
  1405
  >
  		EnumInfos:         file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_enumTypes,
  
  1406
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes,
  
  1407
  >
  	}.Build()
  
  1408
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto = out.File
  
  1409
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes = nil
  
  1410
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs = nil
  
  1411
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/operation.pb.go 25 covered LOC · 2 ranges

Open complete file

  998
  
  }
  
  999
  
  1000
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() }
  
operation.pb.go

  1001
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() {
  
  1002
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto != nil {
  
  1003
  
  		return
  
  1004
  
  	}
  
  1005
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes[2].OneofWrappers = []any{
  
operation.pb.go

  1006
  >
  		(*OperationOutcome_Successful_)(nil),
  
  1007
  >
  		(*OperationOutcome_Failed_)(nil),
  
  1008
  >
  	}
  
  1009
  >
  	type x struct{}
  
  1010
  >
  	out := protoimpl.TypeBuilder{
  
  1011
  >
  		File: protoimpl.DescBuilder{
  
  1012
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1013
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc)),
  
  1014
  >
  			NumEnums:      2,
  
  1015
  >
  			NumMessages:   8,
  
  1016
  >
  			NumExtensions: 0,
  
  1017
  >
  			NumServices:   0,
  
  1018
  >
  		},
  
  1019
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes,
  
  1020
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs,
  
  1021
  >
  		EnumInfos:         file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_enumTypes,
  
  1022
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes,
  
  1023
  >
  	}.Build()
  
  1024
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto = out.File
  
  1025
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes = nil
  
  1026
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs = nil
  
  1027
  
  }

go.temporal.io/server/common/routing/route.go 25 covered LOC · 8 ranges

Open complete file

  36
  
  37
  
  // NewRoute returns a new [Route] instance with the given components.
  
  38
  >
  func NewRoute[T any](components ...Component[T]) Route[T] {
  
route.go

  39
  >
  	return Route[T]{components: components}
  
  40
  >
  }
  
  41
  
  42
  
  // RouteBuilder is a builder for the [Route] interface.

  46
  
  47
  
  // NewBuilder creates a new [RouteBuilder] instance, which can be used to define a new [Route] via a fluent API.
  
  48
  >
  func NewBuilder[T any]() *RouteBuilder[T] {
  
route.go

  49
  >
  	return &RouteBuilder[T]{}
  
  50
  >
  }
  
  51
  
  52
  
  // With adds a series of [Component] instances to the [Route].
  
  53
  >
  func (r *RouteBuilder[T]) With(c ...Component[T]) *RouteBuilder[T] {
  
route.go

  54
  >
  	r.components = append(r.components, c...)
  
  55
  >
  	return r
  
  56
  >
  }
  
  57
  
  58
  
  // Constant adds a [Constant] component to the [Route].
  
  59
  >
  func (r *RouteBuilder[T]) Constant(values ...string) *RouteBuilder[T] {
  
route.go

  60
  >
  	return r.With(Constant[T](values...))
  
  61
  >
  }
  
  62
  
  63
  
  // StringVariable adds a [StringVariable] component to the [Route].
  
  64
  >
  func (r *RouteBuilder[T]) StringVariable(name string, getter func(*T) *string) *RouteBuilder[T] {
  
route.go

  65
  >
  	return r.With(StringVariable[T](name, getter))
  
  66
  >
  }
  
  67
  
  68
  
  // Build returns a read-only [Route].
  
  69
  >
  func (r *RouteBuilder[T]) Build() Route[T] {
  
route.go

  70
  >
  	return NewRoute[T](r.components...)
  
  71
  >
  }
  
  72
  
  73
  
  // Representation returns the [github.com/gorilla/mux] compatible string representation of the route for usage in a

  111
  
  // Constant returns a [Component] that represents a series of constant HTTP path components in a Route.
  
  112
  
  // They will be joined via strings when used to construct a path or path representation.
  
  113
  >
  func Constant[T any](values ...string) constant[T] {
  
route.go

  114
  >
  	return values
  
  115
  >
  }
  
  116
  
  117
  
  type constant[T any] []string

  128
  
  129
  
  // StringVariable returns a [Component] that represents a string variable in a Route.
  
  130
  >
  func StringVariable[T any](name string, getter func(*T) *string) stringVariable[T] {
  
route.go

  131
  >
  	return stringVariable[T]{name, getter}
  
  132
  >
  }
  
  133
  
  134
  
  type stringVariable[T any] struct {

go.temporal.io/server/api/persistence/v1/nexus.pb.go 24 covered LOC · 2 ranges

Open complete file

  481
  
  }
  
  482
  
  483
  >
  func init() { file_temporal_server_api_persistence_v1_nexus_proto_init() }
  
nexus.pb.go

  484
  >
  func file_temporal_server_api_persistence_v1_nexus_proto_init() {
  
  485
  >
  	if File_temporal_server_api_persistence_v1_nexus_proto != nil {
  
  486
  
  		return
  
  487
  
  	}
  
  488
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_msgTypes[1].OneofWrappers = []any{
  
nexus.pb.go

  489
  >
  		(*NexusEndpointTarget_Worker_)(nil),
  
  490
  >
  		(*NexusEndpointTarget_External_)(nil),
  
  491
  >
  	}
  
  492
  >
  	type x struct{}
  
  493
  >
  	out := protoimpl.TypeBuilder{
  
  494
  >
  		File: protoimpl.DescBuilder{
  
  495
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  496
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc), len(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc)),
  
  497
  >
  			NumEnums:      0,
  
  498
  >
  			NumMessages:   6,
  
  499
  >
  			NumExtensions: 0,
  
  500
  >
  			NumServices:   0,
  
  501
  >
  		},
  
  502
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_nexus_proto_goTypes,
  
  503
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_nexus_proto_depIdxs,
  
  504
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_nexus_proto_msgTypes,
  
  505
  >
  	}.Build()
  
  506
  >
  	File_temporal_server_api_persistence_v1_nexus_proto = out.File
  
  507
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_goTypes = nil
  
  508
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_depIdxs = nil
  
  509
  
  }

go.temporal.io/server/api/persistence/v1/workflow_mutable_state.pb.go 24 covered LOC · 2 ranges

Open complete file

  532
  
  }
  
  533
  
  534
  >
  func init() { file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() }
  
workflow_mutable_state.pb.go

  535
  >
  func file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() {
  
  536
  >
  	if File_temporal_server_api_persistence_v1_workflow_mutable_state_proto != nil {
  
  537
  
  		return
  
  538
  
  	}
  
  539
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_init()
  
workflow_mutable_state.pb.go

  540
  >
  	file_temporal_server_api_persistence_v1_executions_proto_init()
  
  541
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  542
  >
  	file_temporal_server_api_persistence_v1_update_proto_init()
  
  543
  >
  	type x struct{}
  
  544
  >
  	out := protoimpl.TypeBuilder{
  
  545
  >
  		File: protoimpl.DescBuilder{
  
  546
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  547
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc), len(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc)),
  
  548
  >
  			NumEnums:      0,
  
  549
  >
  			NumMessages:   16,
  
  550
  >
  			NumExtensions: 0,
  
  551
  >
  			NumServices:   0,
  
  552
  >
  		},
  
  553
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes,
  
  554
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs,
  
  555
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_msgTypes,
  
  556
  >
  	}.Build()
  
  557
  >
  	File_temporal_server_api_persistence_v1_workflow_mutable_state_proto = out.File
  
  558
  >
  	file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes = nil
  
  559
  >
  	file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs = nil
  
  560
  
  }

go.temporal.io/server/api/schedule/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

  1224
  
  }
  
  1225
  
  1226
  >
  func init() { file_temporal_server_api_schedule_v1_message_proto_init() }
  
message.pb.go

  1227
  >
  func file_temporal_server_api_schedule_v1_message_proto_init() {
  
  1228
  >
  	if File_temporal_server_api_schedule_v1_message_proto != nil {
  
  1229
  
  		return
  
  1230
  
  	}
  
  1231
  >
  	file_temporal_server_api_schedule_v1_message_proto_msgTypes[7].OneofWrappers = []any{
  
message.pb.go

  1232
  >
  		(*WatchWorkflowResponse_Result)(nil),
  
  1233
  >
  		(*WatchWorkflowResponse_Failure)(nil),
  
  1234
  >
  	}
  
  1235
  >
  	type x struct{}
  
  1236
  >
  	out := protoimpl.TypeBuilder{
  
  1237
  >
  		File: protoimpl.DescBuilder{
  
  1238
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1239
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_schedule_v1_message_proto_rawDesc), len(file_temporal_server_api_schedule_v1_message_proto_rawDesc)),
  
  1240
  >
  			NumEnums:      0,
  
  1241
  >
  			NumMessages:   13,
  
  1242
  >
  			NumExtensions: 0,
  
  1243
  >
  			NumServices:   0,
  
  1244
  >
  		},
  
  1245
  >
  		GoTypes:           file_temporal_server_api_schedule_v1_message_proto_goTypes,
  
  1246
  >
  		DependencyIndexes: file_temporal_server_api_schedule_v1_message_proto_depIdxs,
  
  1247
  >
  		MessageInfos:      file_temporal_server_api_schedule_v1_message_proto_msgTypes,
  
  1248
  >
  	}.Build()
  
  1249
  >
  	File_temporal_server_api_schedule_v1_message_proto = out.File
  
  1250
  >
  	file_temporal_server_api_schedule_v1_message_proto_goTypes = nil
  
  1251
  >
  	file_temporal_server_api_schedule_v1_message_proto_depIdxs = nil
  
  1252
  
  }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

  462
  
  }
  
  463
  
  464
  >
  func init() { file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() }
  
message.pb.go

  465
  >
  func file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() {
  
  466
  >
  	if File_temporal_server_chasm_lib_callback_proto_v1_message_proto != nil {
  
  467
  
  		return
  
  468
  
  	}
  
  469
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes[1].OneofWrappers = []any{
  
message.pb.go

  470
  >
  		(*Callback_Nexus_)(nil),
  
  471
  >
  	}
  
  472
  >
  	type x struct{}
  
  473
  >
  	out := protoimpl.TypeBuilder{
  
  474
  >
  		File: protoimpl.DescBuilder{
  
  475
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  476
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc)),
  
  477
  >
  			NumEnums:      1,
  
  478
  >
  			NumMessages:   5,
  
  479
  >
  			NumExtensions: 0,
  
  480
  >
  			NumServices:   0,
  
  481
  >
  		},
  
  482
  >
  		GoTypes:           file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes,
  
  483
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs,
  
  484
  >
  		EnumInfos:         file_temporal_server_chasm_lib_callback_proto_v1_message_proto_enumTypes,
  
  485
  >
  		MessageInfos:      file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes,
  
  486
  >
  	}.Build()
  
  487
  >
  	File_temporal_server_chasm_lib_callback_proto_v1_message_proto = out.File
  
  488
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes = nil
  
  489
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs = nil
  
  490
  
  }

go.temporal.io/server/api/enums/v1/predicate.pb.go 23 covered LOC · 3 ranges

Open complete file

  111
  
  }
  
  112
  
  113
  >
  func (PredicateType) Descriptor() protoreflect.EnumDescriptor {
  
predicate.pb.go

  114
  >
  	return file_temporal_server_api_enums_v1_predicate_proto_enumTypes[0].Descriptor()
  
  115
  >
  }
  
  116
  
  117
  
  func (PredicateType) Type() protoreflect.EnumType {

  170
  
  }
  
  171
  
  172
  >
  func init() { file_temporal_server_api_enums_v1_predicate_proto_init() }
  
predicate.pb.go

  173
  >
  func file_temporal_server_api_enums_v1_predicate_proto_init() {
  
  174
  >
  	if File_temporal_server_api_enums_v1_predicate_proto != nil {
  
  175
  
  		return
  
  176
  
  	}
  
  177
  >
  	type x struct{}
  
predicate.pb.go

  178
  >
  	out := protoimpl.TypeBuilder{
  
  179
  >
  		File: protoimpl.DescBuilder{
  
  180
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  181
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),
  
  182
  >
  			NumEnums:      1,
  
  183
  >
  			NumMessages:   0,
  
  184
  >
  			NumExtensions: 0,
  
  185
  >
  			NumServices:   0,
  
  186
  >
  		},
  
  187
  >
  		GoTypes:           file_temporal_server_api_enums_v1_predicate_proto_goTypes,
  
  188
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,
  
  189
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_predicate_proto_enumTypes,
  
  190
  >
  	}.Build()
  
  191
  >
  	File_temporal_server_api_enums_v1_predicate_proto = out.File
  
  192
  >
  	file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil
  
  193
  >
  	file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil
  
  194
  
  }

go.temporal.io/server/api/enums/v1/task.pb.go 23 covered LOC · 3 ranges

Open complete file

  303
  
  }
  
  304
  
  305
  >
  func (TaskType) Descriptor() protoreflect.EnumDescriptor {
  
task.pb.go

  306
  >
  	return file_temporal_server_api_enums_v1_task_proto_enumTypes[1].Descriptor()
  
  307
  >
  }
  
  308
  
  309
  
  func (TaskType) Type() protoreflect.EnumType {

  456
  
  }
  
  457
  
  458
  >
  func init() { file_temporal_server_api_enums_v1_task_proto_init() }
  
task.pb.go

  459
  >
  func file_temporal_server_api_enums_v1_task_proto_init() {
  
  460
  >
  	if File_temporal_server_api_enums_v1_task_proto != nil {
  
  461
  
  		return
  
  462
  
  	}
  
  463
  >
  	type x struct{}
  
task.pb.go

  464
  >
  	out := protoimpl.TypeBuilder{
  
  465
  >
  		File: protoimpl.DescBuilder{
  
  466
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  467
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),
  
  468
  >
  			NumEnums:      3,
  
  469
  >
  			NumMessages:   0,
  
  470
  >
  			NumExtensions: 0,
  
  471
  >
  			NumServices:   0,
  
  472
  >
  		},
  
  473
  >
  		GoTypes:           file_temporal_server_api_enums_v1_task_proto_goTypes,
  
  474
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,
  
  475
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_task_proto_enumTypes,
  
  476
  >
  	}.Build()
  
  477
  >
  	File_temporal_server_api_enums_v1_task_proto = out.File
  
  478
  >
  	file_temporal_server_api_enums_v1_task_proto_goTypes = nil
  
  479
  >
  	file_temporal_server_api_enums_v1_task_proto_depIdxs = nil
  
  480
  
  }

go.temporal.io/server/api/persistence/v1/queues.pb.go 23 covered LOC · 1 range

Open complete file

  616
  
  }
  
  617
  
  618
  >
  func init() { file_temporal_server_api_persistence_v1_queues_proto_init() }
  
queues.pb.go

  619
  >
  func file_temporal_server_api_persistence_v1_queues_proto_init() {
  
  620
  >
  	if File_temporal_server_api_persistence_v1_queues_proto != nil {
  
  621
  >
  		return
  
  622
  >
  	}
  
  623
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_init()
  
  624
  >
  	type x struct{}
  
  625
  >
  	out := protoimpl.TypeBuilder{
  
  626
  >
  		File: protoimpl.DescBuilder{
  
  627
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  628
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queues_proto_rawDesc)),
  
  629
  >
  			NumEnums:      0,
  
  630
  >
  			NumMessages:   12,
  
  631
  >
  			NumExtensions: 0,
  
  632
  >
  			NumServices:   0,
  
  633
  >
  		},
  
  634
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_queues_proto_goTypes,
  
  635
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_queues_proto_depIdxs,
  
  636
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_queues_proto_msgTypes,
  
  637
  >
  	}.Build()
  
  638
  >
  	File_temporal_server_api_persistence_v1_queues_proto = out.File
  
  639
  >
  	file_temporal_server_api_persistence_v1_queues_proto_goTypes = nil
  
  640
  >
  	file_temporal_server_api_persistence_v1_queues_proto_depIdxs = nil
  
  641
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/request_response.pb.go 23 covered LOC · 1 range

Open complete file

  1021
  
  }
  
  1022
  
  1023
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  1024
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() {
  
  1025
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto != nil {
  
  1026
  >
  		return
  
  1027
  >
  	}
  
  1028
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init()
  
  1029
  >
  	type x struct{}
  
  1030
  >
  	out := protoimpl.TypeBuilder{
  
  1031
  >
  		File: protoimpl.DescBuilder{
  
  1032
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1033
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc)),
  
  1034
  >
  			NumEnums:      0,
  
  1035
  >
  			NumMessages:   18,
  
  1036
  >
  			NumExtensions: 0,
  
  1037
  >
  			NumServices:   0,
  
  1038
  >
  		},
  
  1039
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes,
  
  1040
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs,
  
  1041
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_msgTypes,
  
  1042
  >
  	}.Build()
  
  1043
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto = out.File
  
  1044
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes = nil
  
  1045
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs = nil
  
  1046
  
  }

go.temporal.io/server/common/dynamicconfig/shared_structure.go 23 covered LOC · 6 ranges

Open complete file

  17
  
  )
  
  18
  
  19
  >
  func warnDefaultSharedStructure(key string, def any) {
  
shared_structure.go

  20
  >
  	if path := hasSharedStructure(reflect.ValueOf(def), "root"); path != "" {
  
  21
  
  		sharedStructureWarnings.Store(key, path)
  
  22
  
  	}
  
  23
  
  }
  
  24
  
  25
  >
  func logSharedStructureWarnings(logger log.Logger) {
  
shared_structure.go

  26
  >
  	// If you see this warning, it means that a default value used in New*TypedSetting has a
  
  27
  >
  	// non-nil slice or map in it. That can lead to confusing behavior since the value from
  
  28
  >
  	// dynamic config will be merged over the default value (e.g. the slice will be appended
  
  29
  >
  	// to, not replaced). If that behavior is desired, you can avoid this warning by using
  
  30
  >
  	// New*TypedSettingWithConverter and referring to dynamicconfig.ConvertStructure
  
  31
  >
  	// explicitly. Otherwise use nil slices and maps, including at the top level
  
  32
  >
  	// (so `[]string(nil)` instead of `[]string{}`).
  
  33
  >
  	logSharedStructureWarningsOnce.Do(func() {
  
  34
  >
  		sharedStructureWarnings.Range(func(key, path any) bool {
  
  35
  
  			softassert.Fail(logger,
  
  36
  
  				"default value contains shared structure",

  42
  
  }
  
  43
  
  44
  >
  func hasSharedStructure(v reflect.Value, path string) string {
  
shared_structure.go

  45
  >
  	// nolint:exhaustive // deliberately not exhaustive
  
  46
  >
  	switch v.Kind() {
  
  47
  >
  	case reflect.Map, reflect.Slice, reflect.Pointer:
  
  48
  >
  		if !v.IsNil() {
  
  49
  
  			return path
  
  50
  
  		}
  
  51
  >
  	case reflect.Interface:
  
shared_structure.go

  52
  >
  		if !v.IsNil() {
  
  53
  
  			return hasSharedStructure(v.Elem(), path)
  
  54
  
  		}
  
  55
  >
  	case reflect.Struct:
  
shared_structure.go

  56
  >
  		for i := range v.NumField() {
  
  57
  >
  			if p := hasSharedStructure(v.Field(i), path+"."+v.Type().Field(i).Name); p != "" {
  
  58
  
  				return p
  
  59
  
  			}

  66
  
  		}
  
  67
  
  	}
  
  68
  >
  	return ""
  
shared_structure.go

  69
  
  }

go.temporal.io/server/api/common/v1/api_category.pb.go 22 covered LOC · 2 ranges

Open complete file

  204
  
  }
  
  205
  
  206
  >
  func init() { file_temporal_server_api_common_v1_api_category_proto_init() }
  
api_category.pb.go

  207
  >
  func file_temporal_server_api_common_v1_api_category_proto_init() {
  
  208
  >
  	if File_temporal_server_api_common_v1_api_category_proto != nil {
  
  209
  
  		return
  
  210
  
  	}
  
  211
  >
  	type x struct{}
  
api_category.pb.go

  212
  >
  	out := protoimpl.TypeBuilder{
  
  213
  >
  		File: protoimpl.DescBuilder{
  
  214
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  215
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_api_category_proto_rawDesc), len(file_temporal_server_api_common_v1_api_category_proto_rawDesc)),
  
  216
  >
  			NumEnums:      1,
  
  217
  >
  			NumMessages:   1,
  
  218
  >
  			NumExtensions: 1,
  
  219
  >
  			NumServices:   0,
  
  220
  >
  		},
  
  221
  >
  		GoTypes:           file_temporal_server_api_common_v1_api_category_proto_goTypes,
  
  222
  >
  		DependencyIndexes: file_temporal_server_api_common_v1_api_category_proto_depIdxs,
  
  223
  >
  		EnumInfos:         file_temporal_server_api_common_v1_api_category_proto_enumTypes,
  
  224
  >
  		MessageInfos:      file_temporal_server_api_common_v1_api_category_proto_msgTypes,
  
  225
  >
  		ExtensionInfos:    file_temporal_server_api_common_v1_api_category_proto_extTypes,
  
  226
  >
  	}.Build()
  
  227
  >
  	File_temporal_server_api_common_v1_api_category_proto = out.File
  
  228
  >
  	file_temporal_server_api_common_v1_api_category_proto_goTypes = nil
  
  229
  >
  	file_temporal_server_api_common_v1_api_category_proto_depIdxs = nil
  
  230
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  1057
  
  }
  
  1058
  
  1059
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  1060
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() {
  
  1061
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto != nil {
  
  1062
  >
  		return
  
  1063
  >
  	}
  
  1064
  >
  	type x struct{}
  
  1065
  >
  	out := protoimpl.TypeBuilder{
  
  1066
  >
  		File: protoimpl.DescBuilder{
  
  1067
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1068
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc)),
  
  1069
  >
  			NumEnums:      0,
  
  1070
  >
  			NumMessages:   20,
  
  1071
  >
  			NumExtensions: 0,
  
  1072
  >
  			NumServices:   0,
  
  1073
  >
  		},
  
  1074
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes,
  
  1075
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs,
  
  1076
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes,
  
  1077
  >
  	}.Build()
  
  1078
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto = out.File
  
  1079
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes = nil
  
  1080
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs = nil
  
  1081
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  672
  
  }
  
  673
  
  674
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  675
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() {
  
  676
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto != nil {
  
  677
  >
  		return
  
  678
  >
  	}
  
  679
  >
  	type x struct{}
  
  680
  >
  	out := protoimpl.TypeBuilder{
  
  681
  >
  		File: protoimpl.DescBuilder{
  
  682
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  683
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc)),
  
  684
  >
  			NumEnums:      0,
  
  685
  >
  			NumMessages:   12,
  
  686
  >
  			NumExtensions: 0,
  
  687
  >
  			NumServices:   0,
  
  688
  >
  		},
  
  689
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes,
  
  690
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs,
  
  691
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_msgTypes,
  
  692
  >
  	}.Build()
  
  693
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto = out.File
  
  694
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes = nil
  
  695
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs = nil
  
  696
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  157
  
  }
  
  158
  
  159
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  160
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() {
  
  161
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto != nil {
  
  162
  >
  		return
  
  163
  >
  	}
  
  164
  >
  	type x struct{}
  
  165
  >
  	out := protoimpl.TypeBuilder{
  
  166
  >
  		File: protoimpl.DescBuilder{
  
  167
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  168
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc)),
  
  169
  >
  			NumEnums:      0,
  
  170
  >
  			NumMessages:   2,
  
  171
  >
  			NumExtensions: 0,
  
  172
  >
  			NumServices:   0,
  
  173
  >
  		},
  
  174
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes,
  
  175
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs,
  
  176
  >
  		MessageInfos:      file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_msgTypes,
  
  177
  >
  	}.Build()
  
  178
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto = out.File
  
  179
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes = nil
  
  180
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs = nil
  
  181
  
  }

go.temporal.io/server/api/persistence/v1/task_queues.pb.go 21 covered LOC · 2 ranges

Open complete file

  899
  
  }
  
  900
  
  901
  >
  func init() { file_temporal_server_api_persistence_v1_task_queues_proto_init() }
  
task_queues.pb.go

  902
  >
  func file_temporal_server_api_persistence_v1_task_queues_proto_init() {
  
  903
  >
  	if File_temporal_server_api_persistence_v1_task_queues_proto != nil {
  
  904
  
  		return
  
  905
  
  	}
  
  906
  >
  	type x struct{}
  
task_queues.pb.go

  907
  >
  	out := protoimpl.TypeBuilder{
  
  908
  >
  		File: protoimpl.DescBuilder{
  
  909
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  910
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc)),
  
  911
  >
  			NumEnums:      1,
  
  912
  >
  			NumMessages:   13,
  
  913
  >
  			NumExtensions: 0,
  
  914
  >
  			NumServices:   0,
  
  915
  >
  		},
  
  916
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_task_queues_proto_goTypes,
  
  917
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs,
  
  918
  >
  		EnumInfos:         file_temporal_server_api_persistence_v1_task_queues_proto_enumTypes,
  
  919
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_task_queues_proto_msgTypes,
  
  920
  >
  	}.Build()
  
  921
  >
  	File_temporal_server_api_persistence_v1_task_queues_proto = out.File
  
  922
  >
  	file_temporal_server_api_persistence_v1_task_queues_proto_goTypes = nil
  
  923
  >
  	file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs = nil
  
  924
  
  }

go.temporal.io/server/api/routing/v1/extension.pb.go 21 covered LOC · 2 ranges

Open complete file

  144
  
  }
  
  145
  
  146
  >
  func init() { file_temporal_server_api_routing_v1_extension_proto_init() }
  
extension.pb.go

  147
  >
  func file_temporal_server_api_routing_v1_extension_proto_init() {
  
  148
  >
  	if File_temporal_server_api_routing_v1_extension_proto != nil {
  
  149
  
  		return
  
  150
  
  	}
  
  151
  >
  	type x struct{}
  
extension.pb.go

  152
  >
  	out := protoimpl.TypeBuilder{
  
  153
  >
  		File: protoimpl.DescBuilder{
  
  154
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  155
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_routing_v1_extension_proto_rawDesc), len(file_temporal_server_api_routing_v1_extension_proto_rawDesc)),
  
  156
  >
  			NumEnums:      0,
  
  157
  >
  			NumMessages:   1,
  
  158
  >
  			NumExtensions: 1,
  
  159
  >
  			NumServices:   0,
  
  160
  >
  		},
  
  161
  >
  		GoTypes:           file_temporal_server_api_routing_v1_extension_proto_goTypes,
  
  162
  >
  		DependencyIndexes: file_temporal_server_api_routing_v1_extension_proto_depIdxs,
  
  163
  >
  		MessageInfos:      file_temporal_server_api_routing_v1_extension_proto_msgTypes,
  
  164
  >
  		ExtensionInfos:    file_temporal_server_api_routing_v1_extension_proto_extTypes,
  
  165
  >
  	}.Build()
  
  166
  >
  	File_temporal_server_api_routing_v1_extension_proto = out.File
  
  167
  >
  	file_temporal_server_api_routing_v1_extension_proto_goTypes = nil
  
  168
  >
  	file_temporal_server_api_routing_v1_extension_proto_depIdxs = nil
  
  169
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/tasks.pb.go 21 covered LOC · 2 ranges

Open complete file

  495
  
  }
  
  496
  
  497
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  498
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() {
  
  499
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto != nil {
  
  500
  
  		return
  
  501
  
  	}
  
  502
  >
  	type x struct{}
  
tasks.pb.go

  503
  >
  	out := protoimpl.TypeBuilder{
  
  504
  >
  		File: protoimpl.DescBuilder{
  
  505
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  506
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc)),
  
  507
  >
  			NumEnums:      2,
  
  508
  >
  			NumMessages:   5,
  
  509
  >
  			NumExtensions: 0,
  
  510
  >
  			NumServices:   0,
  
  511
  >
  		},
  
  512
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes,
  
  513
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs,
  
  514
  >
  		EnumInfos:         file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_enumTypes,
  
  515
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_msgTypes,
  
  516
  >
  	}.Build()
  
  517
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto = out.File
  
  518
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes = nil
  
  519
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs = nil
  
  520
  
  }

go.temporal.io/server/common/metrics/tags.go 21 covered LOC · 11 ranges

Open complete file

  101
  
  // dual emit the metric with the all tag. If a blank namespace is provided then
  
  102
  
  // this converts that to an unknown namespace.
  
  103
  >
  func NamespaceTag(value string) Tag {
  
tags.go

  104
  >
  	if len(value) == 0 {
  
  105
  
  		value = unknownValue
  
  106
  
  	}
  
  107
  >
  	return Tag{Key: namespace, Value: value}
  
tags.go

  108
  
  }
  
  109

  119
  
  120
  
  // NamespaceUnknownTag returns a new namespace:unknown tag-value
  
  121
  >
  func NamespaceUnknownTag() Tag {
  
tags.go

  122
  >
  	return namespaceUnknownTag
  
  123
  >
  }
  
  124
  
  125
  
  // NamespaceStateTag returns a new namespace state tag.

  279
  
  }
  
  280
  
  281
  >
  func TaskTypeTag(value string) Tag {
  
tags.go

  282
  >
  	if len(value) == 0 {
  
  283
  
  		value = unknownValue
  
  284
  
  	}
  
  285
  >
  	return Tag{Key: TaskTypeTagName, Value: value}
  
tags.go

  286
  
  }
  
  287
  
  288
  >
  func ArchetypeTag(value string) Tag {
  
tags.go

  289
  >
  	if len(value) == 0 {
  
  290
  
  		value = unknownValue
  
  291
  
  	}
  
  292
  >
  	return Tag{Key: ArchetypeTagName, Value: value}
  
tags.go

  293
  
  }
  
  294

  304
  
  }
  
  305
  
  306
  >
  func TaskPriorityTag(value string) Tag {
  
tags.go

  307
  >
  	if len(value) == 0 {
  
  308
  
  		value = unknownValue
  
  309
  
  	}
  
  310
  >
  	return Tag{Key: TaskPriorityTagName, Value: value}
  
tags.go

  311
  
  }
  
  312

  362
  
  }
  
  363
  
  364
  >
  func QueueReaderIDTag(readerID int64) Tag {
  
tags.go

  365
  >
  	return Tag{Key: QueueReaderIDTagName, Value: strconv.Itoa(int(readerID))}
  
  366
  >
  }
  
  367
  
  368
  
  func QueueActionTag(value string) Tag {

  455
  
  }
  
  456
  
  457
  >
  func OperationTag(value string) Tag {
  
tags.go

  458
  >
  	return Tag{Key: OperationTagName, Value: value}
  
  459
  >
  }
  
  460
  
  461
  
  func StringTag(key string, value string) Tag {

go.temporal.io/server/api/adminservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  273
  
  }
  
  274
  
  275
  >
  func init() { file_temporal_server_api_adminservice_v1_service_proto_init() }
  
service.pb.go

  276
  >
  func file_temporal_server_api_adminservice_v1_service_proto_init() {
  
  277
  >
  	if File_temporal_server_api_adminservice_v1_service_proto != nil {
  
  278
  
  		return
  
  279
  
  	}
  
  280
  >
  	file_temporal_server_api_adminservice_v1_request_response_proto_init()
  
service.pb.go

  281
  >
  	type x struct{}
  
  282
  >
  	out := protoimpl.TypeBuilder{
  
  283
  >
  		File: protoimpl.DescBuilder{
  
  284
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  285
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_service_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_service_proto_rawDesc)),
  
  286
  >
  			NumEnums:      0,
  
  287
  >
  			NumMessages:   0,
  
  288
  >
  			NumExtensions: 0,
  
  289
  >
  			NumServices:   1,
  
  290
  >
  		},
  
  291
  >
  		GoTypes:           file_temporal_server_api_adminservice_v1_service_proto_goTypes,
  
  292
  >
  		DependencyIndexes: file_temporal_server_api_adminservice_v1_service_proto_depIdxs,
  
  293
  >
  	}.Build()
  
  294
  >
  	File_temporal_server_api_adminservice_v1_service_proto = out.File
  
  295
  >
  	file_temporal_server_api_adminservice_v1_service_proto_goTypes = nil
  
  296
  >
  	file_temporal_server_api_adminservice_v1_service_proto_depIdxs = nil
  
  297
  
  }

go.temporal.io/server/api/archiver/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  431
  
  }
  
  432
  
  433
  >
  func init() { file_temporal_server_api_archiver_v1_message_proto_init() }
  
message.pb.go

  434
  >
  func file_temporal_server_api_archiver_v1_message_proto_init() {
  
  435
  >
  	if File_temporal_server_api_archiver_v1_message_proto != nil {
  
  436
  
  		return
  
  437
  
  	}
  
  438
  >
  	type x struct{}
  
message.pb.go

  439
  >
  	out := protoimpl.TypeBuilder{
  
  440
  >
  		File: protoimpl.DescBuilder{
  
  441
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  442
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_archiver_v1_message_proto_rawDesc), len(file_temporal_server_api_archiver_v1_message_proto_rawDesc)),
  
  443
  >
  			NumEnums:      0,
  
  444
  >
  			NumMessages:   4,
  
  445
  >
  			NumExtensions: 0,
  
  446
  >
  			NumServices:   0,
  
  447
  >
  		},
  
  448
  >
  		GoTypes:           file_temporal_server_api_archiver_v1_message_proto_goTypes,
  
  449
  >
  		DependencyIndexes: file_temporal_server_api_archiver_v1_message_proto_depIdxs,
  
  450
  >
  		MessageInfos:      file_temporal_server_api_archiver_v1_message_proto_msgTypes,
  
  451
  >
  	}.Build()
  
  452
  >
  	File_temporal_server_api_archiver_v1_message_proto = out.File
  
  453
  >
  	file_temporal_server_api_archiver_v1_message_proto_goTypes = nil
  
  454
  >
  	file_temporal_server_api_archiver_v1_message_proto_depIdxs = nil
  
  455
  
  }

go.temporal.io/server/api/chasm/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  206
  
  }
  
  207
  
  208
  >
  func init() { file_temporal_server_api_chasm_v1_message_proto_init() }
  
message.pb.go

  209
  >
  func file_temporal_server_api_chasm_v1_message_proto_init() {
  
  210
  >
  	if File_temporal_server_api_chasm_v1_message_proto != nil {
  
  211
  
  		return
  
  212
  
  	}
  
  213
  >
  	type x struct{}
  
message.pb.go

  214
  >
  	out := protoimpl.TypeBuilder{
  
  215
  >
  		File: protoimpl.DescBuilder{
  
  216
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  217
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_chasm_v1_message_proto_rawDesc), len(file_temporal_server_api_chasm_v1_message_proto_rawDesc)),
  
  218
  >
  			NumEnums:      0,
  
  219
  >
  			NumMessages:   1,
  
  220
  >
  			NumExtensions: 0,
  
  221
  >
  			NumServices:   0,
  
  222
  >
  		},
  
  223
  >
  		GoTypes:           file_temporal_server_api_chasm_v1_message_proto_goTypes,
  
  224
  >
  		DependencyIndexes: file_temporal_server_api_chasm_v1_message_proto_depIdxs,
  
  225
  >
  		MessageInfos:      file_temporal_server_api_chasm_v1_message_proto_msgTypes,
  
  226
  >
  	}.Build()
  
  227
  >
  	File_temporal_server_api_chasm_v1_message_proto = out.File
  
  228
  >
  	file_temporal_server_api_chasm_v1_message_proto_goTypes = nil
  
  229
  >
  	file_temporal_server_api_chasm_v1_message_proto_depIdxs = nil
  
  230
  
  }

go.temporal.io/server/api/checksum/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  334
  
  }
  
  335
  
  336
  >
  func init() { file_temporal_server_api_checksum_v1_message_proto_init() }
  
message.pb.go

  337
  >
  func file_temporal_server_api_checksum_v1_message_proto_init() {
  
  338
  >
  	if File_temporal_server_api_checksum_v1_message_proto != nil {
  
  339
  
  		return
  
  340
  
  	}
  
  341
  >
  	type x struct{}
  
message.pb.go

  342
  >
  	out := protoimpl.TypeBuilder{
  
  343
  >
  		File: protoimpl.DescBuilder{
  
  344
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  345
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_checksum_v1_message_proto_rawDesc), len(file_temporal_server_api_checksum_v1_message_proto_rawDesc)),
  
  346
  >
  			NumEnums:      0,
  
  347
  >
  			NumMessages:   1,
  
  348
  >
  			NumExtensions: 0,
  
  349
  >
  			NumServices:   0,
  
  350
  >
  		},
  
  351
  >
  		GoTypes:           file_temporal_server_api_checksum_v1_message_proto_goTypes,
  
  352
  >
  		DependencyIndexes: file_temporal_server_api_checksum_v1_message_proto_depIdxs,
  
  353
  >
  		MessageInfos:      file_temporal_server_api_checksum_v1_message_proto_msgTypes,
  
  354
  >
  	}.Build()
  
  355
  >
  	File_temporal_server_api_checksum_v1_message_proto = out.File
  
  356
  >
  	file_temporal_server_api_checksum_v1_message_proto_goTypes = nil
  
  357
  >
  	file_temporal_server_api_checksum_v1_message_proto_depIdxs = nil
  
  358
  
  }

go.temporal.io/server/api/clock/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  193
  
  }
  
  194
  
  195
  >
  func init() { file_temporal_server_api_clock_v1_message_proto_init() }
  
message.pb.go

  196
  >
  func file_temporal_server_api_clock_v1_message_proto_init() {
  
  197
  >
  	if File_temporal_server_api_clock_v1_message_proto != nil {
  
  198
  
  		return
  
  199
  
  	}
  
  200
  >
  	type x struct{}
  
message.pb.go

  201
  >
  	out := protoimpl.TypeBuilder{
  
  202
  >
  		File: protoimpl.DescBuilder{
  
  203
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  204
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_clock_v1_message_proto_rawDesc), len(file_temporal_server_api_clock_v1_message_proto_rawDesc)),
  
  205
  >
  			NumEnums:      0,
  
  206
  >
  			NumMessages:   2,
  
  207
  >
  			NumExtensions: 0,
  
  208
  >
  			NumServices:   0,
  
  209
  >
  		},
  
  210
  >
  		GoTypes:           file_temporal_server_api_clock_v1_message_proto_goTypes,
  
  211
  >
  		DependencyIndexes: file_temporal_server_api_clock_v1_message_proto_depIdxs,
  
  212
  >
  		MessageInfos:      file_temporal_server_api_clock_v1_message_proto_msgTypes,
  
  213
  >
  	}.Build()
  
  214
  >
  	File_temporal_server_api_clock_v1_message_proto = out.File
  
  215
  >
  	file_temporal_server_api_clock_v1_message_proto_goTypes = nil
  
  216
  >
  	file_temporal_server_api_clock_v1_message_proto_depIdxs = nil
  
  217
  
  }

go.temporal.io/server/api/cluster/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  342
  
  }
  
  343
  
  344
  >
  func init() { file_temporal_server_api_cluster_v1_message_proto_init() }
  
message.pb.go

  345
  >
  func file_temporal_server_api_cluster_v1_message_proto_init() {
  
  346
  >
  	if File_temporal_server_api_cluster_v1_message_proto != nil {
  
  347
  
  		return
  
  348
  
  	}
  
  349
  >
  	type x struct{}
  
message.pb.go

  350
  >
  	out := protoimpl.TypeBuilder{
  
  351
  >
  		File: protoimpl.DescBuilder{
  
  352
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  353
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_cluster_v1_message_proto_rawDesc), len(file_temporal_server_api_cluster_v1_message_proto_rawDesc)),
  
  354
  >
  			NumEnums:      0,
  
  355
  >
  			NumMessages:   4,
  
  356
  >
  			NumExtensions: 0,
  
  357
  >
  			NumServices:   0,
  
  358
  >
  		},
  
  359
  >
  		GoTypes:           file_temporal_server_api_cluster_v1_message_proto_goTypes,
  
  360
  >
  		DependencyIndexes: file_temporal_server_api_cluster_v1_message_proto_depIdxs,
  
  361
  >
  		MessageInfos:      file_temporal_server_api_cluster_v1_message_proto_msgTypes,
  
  362
  >
  	}.Build()
  
  363
  >
  	File_temporal_server_api_cluster_v1_message_proto = out.File
  
  364
  >
  	file_temporal_server_api_cluster_v1_message_proto_goTypes = nil
  
  365
  >
  	file_temporal_server_api_cluster_v1_message_proto_depIdxs = nil
  
  366
  
  }

go.temporal.io/server/api/common/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

  295
  
  }
  
  296
  
  297
  >
  func init() { file_temporal_server_api_common_v1_dlq_proto_init() }
  
dlq.pb.go

  298
  >
  func file_temporal_server_api_common_v1_dlq_proto_init() {
  
  299
  >
  	if File_temporal_server_api_common_v1_dlq_proto != nil {
  
  300
  
  		return
  
  301
  
  	}
  
  302
  >
  	type x struct{}
  
dlq.pb.go

  303
  >
  	out := protoimpl.TypeBuilder{
  
  304
  >
  		File: protoimpl.DescBuilder{
  
  305
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  306
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_dlq_proto_rawDesc), len(file_temporal_server_api_common_v1_dlq_proto_rawDesc)),
  
  307
  >
  			NumEnums:      0,
  
  308
  >
  			NumMessages:   4,
  
  309
  >
  			NumExtensions: 0,
  
  310
  >
  			NumServices:   0,
  
  311
  >
  		},
  
  312
  >
  		GoTypes:           file_temporal_server_api_common_v1_dlq_proto_goTypes,
  
  313
  >
  		DependencyIndexes: file_temporal_server_api_common_v1_dlq_proto_depIdxs,
  
  314
  >
  		MessageInfos:      file_temporal_server_api_common_v1_dlq_proto_msgTypes,
  
  315
  >
  	}.Build()
  
  316
  >
  	File_temporal_server_api_common_v1_dlq_proto = out.File
  
  317
  >
  	file_temporal_server_api_common_v1_dlq_proto_goTypes = nil
  
  318
  >
  	file_temporal_server_api_common_v1_dlq_proto_depIdxs = nil
  
  319
  
  }

go.temporal.io/server/api/contextpropagation/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  109
  
  }
  
  110
  
  111
  >
  func init() { file_temporal_server_api_contextpropagation_v1_message_proto_init() }
  
message.pb.go

  112
  >
  func file_temporal_server_api_contextpropagation_v1_message_proto_init() {
  
  113
  >
  	if File_temporal_server_api_contextpropagation_v1_message_proto != nil {
  
  114
  
  		return
  
  115
  
  	}
  
  116
  >
  	type x struct{}
  
message.pb.go

  117
  >
  	out := protoimpl.TypeBuilder{
  
  118
  >
  		File: protoimpl.DescBuilder{
  
  119
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  120
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc), len(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc)),
  
  121
  >
  			NumEnums:      0,
  
  122
  >
  			NumMessages:   2,
  
  123
  >
  			NumExtensions: 0,
  
  124
  >
  			NumServices:   0,
  
  125
  >
  		},
  
  126
  >
  		GoTypes:           file_temporal_server_api_contextpropagation_v1_message_proto_goTypes,
  
  127
  >
  		DependencyIndexes: file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs,
  
  128
  >
  		MessageInfos:      file_temporal_server_api_contextpropagation_v1_message_proto_msgTypes,
  
  129
  >
  	}.Build()
  
  130
  >
  	File_temporal_server_api_contextpropagation_v1_message_proto = out.File
  
  131
  >
  	file_temporal_server_api_contextpropagation_v1_message_proto_goTypes = nil
  
  132
  >
  	file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs = nil
  
  133
  
  }

go.temporal.io/server/api/deployment/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  4626
  
  }
  
  4627
  
  4628
  >
  func init() { file_temporal_server_api_deployment_v1_message_proto_init() }
  
message.pb.go

  4629
  >
  func file_temporal_server_api_deployment_v1_message_proto_init() {
  
  4630
  >
  	if File_temporal_server_api_deployment_v1_message_proto != nil {
  
  4631
  
  		return
  
  4632
  
  	}
  
  4633
  >
  	type x struct{}
  
message.pb.go

  4634
  >
  	out := protoimpl.TypeBuilder{
  
  4635
  >
  		File: protoimpl.DescBuilder{
  
  4636
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  4637
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_deployment_v1_message_proto_rawDesc), len(file_temporal_server_api_deployment_v1_message_proto_rawDesc)),
  
  4638
  >
  			NumEnums:      0,
  
  4639
  >
  			NumMessages:   75,
  
  4640
  >
  			NumExtensions: 0,
  
  4641
  >
  			NumServices:   0,
  
  4642
  >
  		},
  
  4643
  >
  		GoTypes:           file_temporal_server_api_deployment_v1_message_proto_goTypes,
  
  4644
  >
  		DependencyIndexes: file_temporal_server_api_deployment_v1_message_proto_depIdxs,
  
  4645
  >
  		MessageInfos:      file_temporal_server_api_deployment_v1_message_proto_msgTypes,
  
  4646
  >
  	}.Build()
  
  4647
  >
  	File_temporal_server_api_deployment_v1_message_proto = out.File
  
  4648
  >
  	file_temporal_server_api_deployment_v1_message_proto_goTypes = nil
  
  4649
  >
  	file_temporal_server_api_deployment_v1_message_proto_depIdxs = nil
  
  4650
  
  }

go.temporal.io/server/api/enums/v1/cluster.pb.go 20 covered LOC · 2 ranges

Open complete file

  209
  
  }
  
  210
  
  211
  >
  func init() { file_temporal_server_api_enums_v1_cluster_proto_init() }
  
cluster.pb.go

  212
  >
  func file_temporal_server_api_enums_v1_cluster_proto_init() {
  
  213
  >
  	if File_temporal_server_api_enums_v1_cluster_proto != nil {
  
  214
  
  		return
  
  215
  
  	}
  
  216
  >
  	type x struct{}
  
cluster.pb.go

  217
  >
  	out := protoimpl.TypeBuilder{
  
  218
  >
  		File: protoimpl.DescBuilder{
  
  219
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  220
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_cluster_proto_rawDesc), len(file_temporal_server_api_enums_v1_cluster_proto_rawDesc)),
  
  221
  >
  			NumEnums:      2,
  
  222
  >
  			NumMessages:   0,
  
  223
  >
  			NumExtensions: 0,
  
  224
  >
  			NumServices:   0,
  
  225
  >
  		},
  
  226
  >
  		GoTypes:           file_temporal_server_api_enums_v1_cluster_proto_goTypes,
  
  227
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_cluster_proto_depIdxs,
  
  228
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_cluster_proto_enumTypes,
  
  229
  >
  	}.Build()
  
  230
  >
  	File_temporal_server_api_enums_v1_cluster_proto = out.File
  
  231
  >
  	file_temporal_server_api_enums_v1_cluster_proto_goTypes = nil
  
  232
  >
  	file_temporal_server_api_enums_v1_cluster_proto_depIdxs = nil
  
  233
  
  }

go.temporal.io/server/api/enums/v1/common.pb.go 20 covered LOC · 2 ranges

Open complete file

  264
  
  }
  
  265
  
  266
  >
  func init() { file_temporal_server_api_enums_v1_common_proto_init() }
  
common.pb.go

  267
  >
  func file_temporal_server_api_enums_v1_common_proto_init() {
  
  268
  >
  	if File_temporal_server_api_enums_v1_common_proto != nil {
  
  269
  
  		return
  
  270
  
  	}
  
  271
  >
  	type x struct{}
  
common.pb.go

  272
  >
  	out := protoimpl.TypeBuilder{
  
  273
  >
  		File: protoimpl.DescBuilder{
  
  274
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  275
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),
  
  276
  >
  			NumEnums:      3,
  
  277
  >
  			NumMessages:   0,
  
  278
  >
  			NumExtensions: 0,
  
  279
  >
  			NumServices:   0,
  
  280
  >
  		},
  
  281
  >
  		GoTypes:           file_temporal_server_api_enums_v1_common_proto_goTypes,
  
  282
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,
  
  283
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_common_proto_enumTypes,
  
  284
  >
  	}.Build()
  
  285
  >
  	File_temporal_server_api_enums_v1_common_proto = out.File
  
  286
  >
  	file_temporal_server_api_enums_v1_common_proto_goTypes = nil
  
  287
  >
  	file_temporal_server_api_enums_v1_common_proto_depIdxs = nil
  
  288
  
  }

go.temporal.io/server/api/enums/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

  187
  
  }
  
  188
  
  189
  >
  func init() { file_temporal_server_api_enums_v1_dlq_proto_init() }
  
dlq.pb.go

  190
  >
  func file_temporal_server_api_enums_v1_dlq_proto_init() {
  
  191
  >
  	if File_temporal_server_api_enums_v1_dlq_proto != nil {
  
  192
  
  		return
  
  193
  
  	}
  
  194
  >
  	type x struct{}
  
dlq.pb.go

  195
  >
  	out := protoimpl.TypeBuilder{
  
  196
  >
  		File: protoimpl.DescBuilder{
  
  197
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  198
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_dlq_proto_rawDesc), len(file_temporal_server_api_enums_v1_dlq_proto_rawDesc)),
  
  199
  >
  			NumEnums:      2,
  
  200
  >
  			NumMessages:   0,
  
  201
  >
  			NumExtensions: 0,
  
  202
  >
  			NumServices:   0,
  
  203
  >
  		},
  
  204
  >
  		GoTypes:           file_temporal_server_api_enums_v1_dlq_proto_goTypes,
  
  205
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_dlq_proto_depIdxs,
  
  206
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_dlq_proto_enumTypes,
  
  207
  >
  	}.Build()
  
  208
  >
  	File_temporal_server_api_enums_v1_dlq_proto = out.File
  
  209
  >
  	file_temporal_server_api_enums_v1_dlq_proto_goTypes = nil
  
  210
  >
  	file_temporal_server_api_enums_v1_dlq_proto_depIdxs = nil
  
  211
  
  }

go.temporal.io/server/api/enums/v1/fairness_state.pb.go 20 covered LOC · 2 ranges

Open complete file

  123
  
  }
  
  124
  
  125
  >
  func init() { file_temporal_server_api_enums_v1_fairness_state_proto_init() }
  
fairness_state.pb.go

  126
  >
  func file_temporal_server_api_enums_v1_fairness_state_proto_init() {
  
  127
  >
  	if File_temporal_server_api_enums_v1_fairness_state_proto != nil {
  
  128
  
  		return
  
  129
  
  	}
  
  130
  >
  	type x struct{}
  
fairness_state.pb.go

  131
  >
  	out := protoimpl.TypeBuilder{
  
  132
  >
  		File: protoimpl.DescBuilder{
  
  133
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  134
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc), len(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc)),
  
  135
  >
  			NumEnums:      1,
  
  136
  >
  			NumMessages:   0,
  
  137
  >
  			NumExtensions: 0,
  
  138
  >
  			NumServices:   0,
  
  139
  >
  		},
  
  140
  >
  		GoTypes:           file_temporal_server_api_enums_v1_fairness_state_proto_goTypes,
  
  141
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs,
  
  142
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes,
  
  143
  >
  	}.Build()
  
  144
  >
  	File_temporal_server_api_enums_v1_fairness_state_proto = out.File
  
  145
  >
  	file_temporal_server_api_enums_v1_fairness_state_proto_goTypes = nil
  
  146
  >
  	file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs = nil
  
  147
  
  }

go.temporal.io/server/api/enums/v1/nexus.pb.go 20 covered LOC · 2 ranges

Open complete file

  158
  
  }
  
  159
  
  160
  >
  func init() { file_temporal_server_api_enums_v1_nexus_proto_init() }
  
nexus.pb.go

  161
  >
  func file_temporal_server_api_enums_v1_nexus_proto_init() {
  
  162
  >
  	if File_temporal_server_api_enums_v1_nexus_proto != nil {
  
  163
  
  		return
  
  164
  
  	}
  
  165
  >
  	type x struct{}
  
nexus.pb.go

  166
  >
  	out := protoimpl.TypeBuilder{
  
  167
  >
  		File: protoimpl.DescBuilder{
  
  168
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  169
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),
  
  170
  >
  			NumEnums:      1,
  
  171
  >
  			NumMessages:   0,
  
  172
  >
  			NumExtensions: 0,
  
  173
  >
  			NumServices:   0,
  
  174
  >
  		},
  
  175
  >
  		GoTypes:           file_temporal_server_api_enums_v1_nexus_proto_goTypes,
  
  176
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,
  
  177
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_nexus_proto_enumTypes,
  
  178
  >
  	}.Build()
  
  179
  >
  	File_temporal_server_api_enums_v1_nexus_proto = out.File
  
  180
  >
  	file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil
  
  181
  >
  	file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil
  
  182
  
  }

go.temporal.io/server/api/enums/v1/replication.pb.go 20 covered LOC · 2 ranges

Open complete file

  314
  
  }
  
  315
  
  316
  >
  func init() { file_temporal_server_api_enums_v1_replication_proto_init() }
  
replication.pb.go

  317
  >
  func file_temporal_server_api_enums_v1_replication_proto_init() {
  
  318
  >
  	if File_temporal_server_api_enums_v1_replication_proto != nil {
  
  319
  
  		return
  
  320
  
  	}
  
  321
  >
  	type x struct{}
  
replication.pb.go

  322
  >
  	out := protoimpl.TypeBuilder{
  
  323
  >
  		File: protoimpl.DescBuilder{
  
  324
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  325
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_replication_proto_rawDesc), len(file_temporal_server_api_enums_v1_replication_proto_rawDesc)),
  
  326
  >
  			NumEnums:      3,
  
  327
  >
  			NumMessages:   0,
  
  328
  >
  			NumExtensions: 0,
  
  329
  >
  			NumServices:   0,
  
  330
  >
  		},
  
  331
  >
  		GoTypes:           file_temporal_server_api_enums_v1_replication_proto_goTypes,
  
  332
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_replication_proto_depIdxs,
  
  333
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_replication_proto_enumTypes,
  
  334
  >
  	}.Build()
  
  335
  >
  	File_temporal_server_api_enums_v1_replication_proto = out.File
  
  336
  >
  	file_temporal_server_api_enums_v1_replication_proto_goTypes = nil
  
  337
  >
  	file_temporal_server_api_enums_v1_replication_proto_depIdxs = nil
  
  338
  
  }

go.temporal.io/server/api/enums/v1/workflow.pb.go 20 covered LOC · 2 ranges

Open complete file

  275
  
  }
  
  276
  
  277
  >
  func init() { file_temporal_server_api_enums_v1_workflow_proto_init() }
  
workflow.pb.go

  278
  >
  func file_temporal_server_api_enums_v1_workflow_proto_init() {
  
  279
  >
  	if File_temporal_server_api_enums_v1_workflow_proto != nil {
  
  280
  
  		return
  
  281
  
  	}
  
  282
  >
  	type x struct{}
  
workflow.pb.go

  283
  >
  	out := protoimpl.TypeBuilder{
  
  284
  >
  		File: protoimpl.DescBuilder{
  
  285
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  286
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),
  
  287
  >
  			NumEnums:      3,
  
  288
  >
  			NumMessages:   0,
  
  289
  >
  			NumExtensions: 0,
  
  290
  >
  			NumServices:   0,
  
  291
  >
  		},
  
  292
  >
  		GoTypes:           file_temporal_server_api_enums_v1_workflow_proto_goTypes,
  
  293
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,
  
  294
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_workflow_proto_enumTypes,
  
  295
  >
  	}.Build()
  
  296
  >
  	File_temporal_server_api_enums_v1_workflow_proto = out.File
  
  297
  >
  	file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil
  
  298
  >
  	file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil
  
  299
  
  }

go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 20 covered LOC · 2 ranges

Open complete file

  124
  
  }
  
  125
  
  126
  >
  func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() }
  
workflow_task_type.pb.go

  127
  >
  func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {
  
  128
  >
  	if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {
  
  129
  
  		return
  
  130
  
  	}
  
  131
  >
  	type x struct{}
  
workflow_task_type.pb.go

  132
  >
  	out := protoimpl.TypeBuilder{
  
  133
  >
  		File: protoimpl.DescBuilder{
  
  134
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  135
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),
  
  136
  >
  			NumEnums:      1,
  
  137
  >
  			NumMessages:   0,
  
  138
  >
  			NumExtensions: 0,
  
  139
  >
  			NumServices:   0,
  
  140
  >
  		},
  
  141
  >
  		GoTypes:           file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,
  
  142
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,
  
  143
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,
  
  144
  >
  	}.Build()
  
  145
  >
  	File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File
  
  146
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil
  
  147
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil
  
  148
  
  }

go.temporal.io/server/api/errordetails/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  625
  
  }
  
  626
  
  627
  >
  func init() { file_temporal_server_api_errordetails_v1_message_proto_init() }
  
message.pb.go

  628
  >
  func file_temporal_server_api_errordetails_v1_message_proto_init() {
  
  629
  >
  	if File_temporal_server_api_errordetails_v1_message_proto != nil {
  
  630
  
  		return
  
  631
  
  	}
  
  632
  >
  	type x struct{}
  
message.pb.go

  633
  >
  	out := protoimpl.TypeBuilder{
  
  634
  >
  		File: protoimpl.DescBuilder{
  
  635
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  636
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_errordetails_v1_message_proto_rawDesc), len(file_temporal_server_api_errordetails_v1_message_proto_rawDesc)),
  
  637
  >
  			NumEnums:      0,
  
  638
  >
  			NumMessages:   10,
  
  639
  >
  			NumExtensions: 0,
  
  640
  >
  			NumServices:   0,
  
  641
  >
  		},
  
  642
  >
  		GoTypes:           file_temporal_server_api_errordetails_v1_message_proto_goTypes,
  
  643
  >
  		DependencyIndexes: file_temporal_server_api_errordetails_v1_message_proto_depIdxs,
  
  644
  >
  		MessageInfos:      file_temporal_server_api_errordetails_v1_message_proto_msgTypes,
  
  645
  >
  	}.Build()
  
  646
  >
  	File_temporal_server_api_errordetails_v1_message_proto = out.File
  
  647
  >
  	file_temporal_server_api_errordetails_v1_message_proto_goTypes = nil
  
  648
  >
  	file_temporal_server_api_errordetails_v1_message_proto_depIdxs = nil
  
  649
  
  }

go.temporal.io/server/api/health/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  300
  
  }
  
  301
  
  302
  >
  func init() { file_temporal_server_api_health_v1_message_proto_init() }
  
message.pb.go

  303
  >
  func file_temporal_server_api_health_v1_message_proto_init() {
  
  304
  >
  	if File_temporal_server_api_health_v1_message_proto != nil {
  
  305
  
  		return
  
  306
  
  	}
  
  307
  >
  	type x struct{}
  
message.pb.go

  308
  >
  	out := protoimpl.TypeBuilder{
  
  309
  >
  		File: protoimpl.DescBuilder{
  
  310
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  311
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_health_v1_message_proto_rawDesc), len(file_temporal_server_api_health_v1_message_proto_rawDesc)),
  
  312
  >
  			NumEnums:      0,
  
  313
  >
  			NumMessages:   3,
  
  314
  >
  			NumExtensions: 0,
  
  315
  >
  			NumServices:   0,
  
  316
  >
  		},
  
  317
  >
  		GoTypes:           file_temporal_server_api_health_v1_message_proto_goTypes,
  
  318
  >
  		DependencyIndexes: file_temporal_server_api_health_v1_message_proto_depIdxs,
  
  319
  >
  		MessageInfos:      file_temporal_server_api_health_v1_message_proto_msgTypes,
  
  320
  >
  	}.Build()
  
  321
  >
  	File_temporal_server_api_health_v1_message_proto = out.File
  
  322
  >
  	file_temporal_server_api_health_v1_message_proto_goTypes = nil
  
  323
  >
  	file_temporal_server_api_health_v1_message_proto_depIdxs = nil
  
  324
  
  }

go.temporal.io/server/api/history/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  498
  
  }
  
  499
  
  500
  >
  func init() { file_temporal_server_api_history_v1_message_proto_init() }
  
message.pb.go

  501
  >
  func file_temporal_server_api_history_v1_message_proto_init() {
  
  502
  >
  	if File_temporal_server_api_history_v1_message_proto != nil {
  
  503
  
  		return
  
  504
  
  	}
  
  505
  >
  	type x struct{}
  
message.pb.go

  506
  >
  	out := protoimpl.TypeBuilder{
  
  507
  >
  		File: protoimpl.DescBuilder{
  
  508
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  509
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_history_v1_message_proto_rawDesc), len(file_temporal_server_api_history_v1_message_proto_rawDesc)),
  
  510
  >
  			NumEnums:      0,
  
  511
  >
  			NumMessages:   8,
  
  512
  >
  			NumExtensions: 0,
  
  513
  >
  			NumServices:   0,
  
  514
  >
  		},
  
  515
  >
  		GoTypes:           file_temporal_server_api_history_v1_message_proto_goTypes,
  
  516
  >
  		DependencyIndexes: file_temporal_server_api_history_v1_message_proto_depIdxs,
  
  517
  >
  		MessageInfos:      file_temporal_server_api_history_v1_message_proto_msgTypes,
  
  518
  >
  	}.Build()
  
  519
  >
  	File_temporal_server_api_history_v1_message_proto = out.File
  
  520
  >
  	file_temporal_server_api_history_v1_message_proto_goTypes = nil
  
  521
  >
  	file_temporal_server_api_history_v1_message_proto_depIdxs = nil
  
  522
  
  }

go.temporal.io/server/api/historyservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  428
  
  }
  
  429
  
  430
  >
  func init() { file_temporal_server_api_historyservice_v1_service_proto_init() }
  
service.pb.go

  431
  >
  func file_temporal_server_api_historyservice_v1_service_proto_init() {
  
  432
  >
  	if File_temporal_server_api_historyservice_v1_service_proto != nil {
  
  433
  
  		return
  
  434
  
  	}
  
  435
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_init()
  
service.pb.go

  436
  >
  	type x struct{}
  
  437
  >
  	out := protoimpl.TypeBuilder{
  
  438
  >
  		File: protoimpl.DescBuilder{
  
  439
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  440
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_service_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_service_proto_rawDesc)),
  
  441
  >
  			NumEnums:      0,
  
  442
  >
  			NumMessages:   0,
  
  443
  >
  			NumExtensions: 0,
  
  444
  >
  			NumServices:   1,
  
  445
  >
  		},
  
  446
  >
  		GoTypes:           file_temporal_server_api_historyservice_v1_service_proto_goTypes,
  
  447
  >
  		DependencyIndexes: file_temporal_server_api_historyservice_v1_service_proto_depIdxs,
  
  448
  >
  	}.Build()
  
  449
  >
  	File_temporal_server_api_historyservice_v1_service_proto = out.File
  
  450
  >
  	file_temporal_server_api_historyservice_v1_service_proto_goTypes = nil
  
  451
  >
  	file_temporal_server_api_historyservice_v1_service_proto_depIdxs = nil
  
  452
  
  }

go.temporal.io/server/api/matchingservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  250
  
  }
  
  251
  
  252
  >
  func init() { file_temporal_server_api_matchingservice_v1_service_proto_init() }
  
service.pb.go

  253
  >
  func file_temporal_server_api_matchingservice_v1_service_proto_init() {
  
  254
  >
  	if File_temporal_server_api_matchingservice_v1_service_proto != nil {
  
  255
  
  		return
  
  256
  
  	}
  
  257
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_init()
  
service.pb.go

  258
  >
  	type x struct{}
  
  259
  >
  	out := protoimpl.TypeBuilder{
  
  260
  >
  		File: protoimpl.DescBuilder{
  
  261
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  262
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc)),
  
  263
  >
  			NumEnums:      0,
  
  264
  >
  			NumMessages:   0,
  
  265
  >
  			NumExtensions: 0,
  
  266
  >
  			NumServices:   1,
  
  267
  >
  		},
  
  268
  >
  		GoTypes:           file_temporal_server_api_matchingservice_v1_service_proto_goTypes,
  
  269
  >
  		DependencyIndexes: file_temporal_server_api_matchingservice_v1_service_proto_depIdxs,
  
  270
  >
  	}.Build()
  
  271
  >
  	File_temporal_server_api_matchingservice_v1_service_proto = out.File
  
  272
  >
  	file_temporal_server_api_matchingservice_v1_service_proto_goTypes = nil
  
  273
  >
  	file_temporal_server_api_matchingservice_v1_service_proto_depIdxs = nil
  
  274
  
  }

go.temporal.io/server/api/metrics/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  104
  
  }
  
  105
  
  106
  >
  func init() { file_temporal_server_api_metrics_v1_message_proto_init() }
  
message.pb.go

  107
  >
  func file_temporal_server_api_metrics_v1_message_proto_init() {
  
  108
  >
  	if File_temporal_server_api_metrics_v1_message_proto != nil {
  
  109
  
  		return
  
  110
  
  	}
  
  111
  >
  	type x struct{}
  
message.pb.go

  112
  >
  	out := protoimpl.TypeBuilder{
  
  113
  >
  		File: protoimpl.DescBuilder{
  
  114
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  115
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_metrics_v1_message_proto_rawDesc), len(file_temporal_server_api_metrics_v1_message_proto_rawDesc)),
  
  116
  >
  			NumEnums:      0,
  
  117
  >
  			NumMessages:   2,
  
  118
  >
  			NumExtensions: 0,
  
  119
  >
  			NumServices:   0,
  
  120
  >
  		},
  
  121
  >
  		GoTypes:           file_temporal_server_api_metrics_v1_message_proto_goTypes,
  
  122
  >
  		DependencyIndexes: file_temporal_server_api_metrics_v1_message_proto_depIdxs,
  
  123
  >
  		MessageInfos:      file_temporal_server_api_metrics_v1_message_proto_msgTypes,
  
  124
  >
  	}.Build()
  
  125
  >
  	File_temporal_server_api_metrics_v1_message_proto = out.File
  
  126
  >
  	file_temporal_server_api_metrics_v1_message_proto_goTypes = nil
  
  127
  >
  	file_temporal_server_api_metrics_v1_message_proto_depIdxs = nil
  
  128
  
  }

go.temporal.io/server/api/namespace/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  114
  
  }
  
  115
  
  116
  >
  func init() { file_temporal_server_api_namespace_v1_message_proto_init() }
  
message.pb.go

  117
  >
  func file_temporal_server_api_namespace_v1_message_proto_init() {
  
  118
  >
  	if File_temporal_server_api_namespace_v1_message_proto != nil {
  
  119
  
  		return
  
  120
  
  	}
  
  121
  >
  	type x struct{}
  
message.pb.go

  122
  >
  	out := protoimpl.TypeBuilder{
  
  123
  >
  		File: protoimpl.DescBuilder{
  
  124
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  125
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_namespace_v1_message_proto_rawDesc), len(file_temporal_server_api_namespace_v1_message_proto_rawDesc)),
  
  126
  >
  			NumEnums:      0,
  
  127
  >
  			NumMessages:   1,
  
  128
  >
  			NumExtensions: 0,
  
  129
  >
  			NumServices:   0,
  
  130
  >
  		},
  
  131
  >
  		GoTypes:           file_temporal_server_api_namespace_v1_message_proto_goTypes,
  
  132
  >
  		DependencyIndexes: file_temporal_server_api_namespace_v1_message_proto_depIdxs,
  
  133
  >
  		MessageInfos:      file_temporal_server_api_namespace_v1_message_proto_msgTypes,
  
  134
  >
  	}.Build()
  
  135
  >
  	File_temporal_server_api_namespace_v1_message_proto = out.File
  
  136
  >
  	file_temporal_server_api_namespace_v1_message_proto_goTypes = nil
  
  137
  >
  	file_temporal_server_api_namespace_v1_message_proto_depIdxs = nil
  
  138
  
  }

go.temporal.io/server/api/persistence/v1/chasm_visibility.pb.go 20 covered LOC · 2 ranges

Open complete file

  146
  
  }
  
  147
  
  148
  >
  func init() { file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() }
  
chasm_visibility.pb.go

  149
  >
  func file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() {
  
  150
  >
  	if File_temporal_server_api_persistence_v1_chasm_visibility_proto != nil {
  
  151
  
  		return
  
  152
  
  	}
  
  153
  >
  	type x struct{}
  
chasm_visibility.pb.go

  154
  >
  	out := protoimpl.TypeBuilder{
  
  155
  >
  		File: protoimpl.DescBuilder{
  
  156
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  157
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc)),
  
  158
  >
  			NumEnums:      0,
  
  159
  >
  			NumMessages:   2,
  
  160
  >
  			NumExtensions: 0,
  
  161
  >
  			NumServices:   0,
  
  162
  >
  		},
  
  163
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes,
  
  164
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs,
  
  165
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_chasm_visibility_proto_msgTypes,
  
  166
  >
  	}.Build()
  
  167
  >
  	File_temporal_server_api_persistence_v1_chasm_visibility_proto = out.File
  
  168
  >
  	file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes = nil
  
  169
  >
  	file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs = nil
  
  170
  
  }

go.temporal.io/server/api/persistence/v1/cluster_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

  289
  
  }
  
  290
  
  291
  >
  func init() { file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() }
  
cluster_metadata.pb.go

  292
  >
  func file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() {
  
  293
  >
  	if File_temporal_server_api_persistence_v1_cluster_metadata_proto != nil {
  
  294
  
  		return
  
  295
  
  	}
  
  296
  >
  	type x struct{}
  
cluster_metadata.pb.go

  297
  >
  	out := protoimpl.TypeBuilder{
  
  298
  >
  		File: protoimpl.DescBuilder{
  
  299
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  300
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc)),
  
  301
  >
  			NumEnums:      0,
  
  302
  >
  			NumMessages:   5,
  
  303
  >
  			NumExtensions: 0,
  
  304
  >
  			NumServices:   0,
  
  305
  >
  		},
  
  306
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes,
  
  307
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs,
  
  308
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_cluster_metadata_proto_msgTypes,
  
  309
  >
  	}.Build()
  
  310
  >
  	File_temporal_server_api_persistence_v1_cluster_metadata_proto = out.File
  
  311
  >
  	file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes = nil
  
  312
  >
  	file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs = nil
  
  313
  
  }

go.temporal.io/server/api/persistence/v1/history_tree.pb.go 20 covered LOC · 2 ranges

Open complete file

  274
  
  }
  
  275
  
  276
  >
  func init() { file_temporal_server_api_persistence_v1_history_tree_proto_init() }
  
history_tree.pb.go

  277
  >
  func file_temporal_server_api_persistence_v1_history_tree_proto_init() {
  
  278
  >
  	if File_temporal_server_api_persistence_v1_history_tree_proto != nil {
  
  279
  
  		return
  
  280
  
  	}
  
  281
  >
  	type x struct{}
  
history_tree.pb.go

  282
  >
  	out := protoimpl.TypeBuilder{
  
  283
  >
  		File: protoimpl.DescBuilder{
  
  284
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  285
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc), len(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc)),
  
  286
  >
  			NumEnums:      0,
  
  287
  >
  			NumMessages:   3,
  
  288
  >
  			NumExtensions: 0,
  
  289
  >
  			NumServices:   0,
  
  290
  >
  		},
  
  291
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_history_tree_proto_goTypes,
  
  292
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs,
  
  293
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes,
  
  294
  >
  	}.Build()
  
  295
  >
  	File_temporal_server_api_persistence_v1_history_tree_proto = out.File
  
  296
  >
  	file_temporal_server_api_persistence_v1_history_tree_proto_goTypes = nil
  
  297
  >
  	file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs = nil
  
  298
  
  }

go.temporal.io/server/api/persistence/v1/namespaces.pb.go 20 covered LOC · 2 ranges

Open complete file

  536
  
  }
  
  537
  
  538
  >
  func init() { file_temporal_server_api_persistence_v1_namespaces_proto_init() }
  
namespaces.pb.go

  539
  >
  func file_temporal_server_api_persistence_v1_namespaces_proto_init() {
  
  540
  >
  	if File_temporal_server_api_persistence_v1_namespaces_proto != nil {
  
  541
  
  		return
  
  542
  
  	}
  
  543
  >
  	type x struct{}
  
namespaces.pb.go

  544
  >
  	out := protoimpl.TypeBuilder{
  
  545
  >
  		File: protoimpl.DescBuilder{
  
  546
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  547
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc), len(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc)),
  
  548
  >
  			NumEnums:      0,
  
  549
  >
  			NumMessages:   8,
  
  550
  >
  			NumExtensions: 0,
  
  551
  >
  			NumServices:   0,
  
  552
  >
  		},
  
  553
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_namespaces_proto_goTypes,
  
  554
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs,
  
  555
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_namespaces_proto_msgTypes,
  
  556
  >
  	}.Build()
  
  557
  >
  	File_temporal_server_api_persistence_v1_namespaces_proto = out.File
  
  558
  >
  	file_temporal_server_api_persistence_v1_namespaces_proto_goTypes = nil
  
  559
  >
  	file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs = nil
  
  560
  
  }

go.temporal.io/server/api/persistence/v1/queue_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

  105
  
  }
  
  106
  
  107
  >
  func init() { file_temporal_server_api_persistence_v1_queue_metadata_proto_init() }
  
queue_metadata.pb.go

  108
  >
  func file_temporal_server_api_persistence_v1_queue_metadata_proto_init() {
  
  109
  >
  	if File_temporal_server_api_persistence_v1_queue_metadata_proto != nil {
  
  110
  
  		return
  
  111
  
  	}
  
  112
  >
  	type x struct{}
  
queue_metadata.pb.go

  113
  >
  	out := protoimpl.TypeBuilder{
  
  114
  >
  		File: protoimpl.DescBuilder{
  
  115
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  116
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc)),
  
  117
  >
  			NumEnums:      0,
  
  118
  >
  			NumMessages:   2,
  
  119
  >
  			NumExtensions: 0,
  
  120
  >
  			NumServices:   0,
  
  121
  >
  		},
  
  122
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes,
  
  123
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs,
  
  124
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_queue_metadata_proto_msgTypes,
  
  125
  >
  	}.Build()
  
  126
  >
  	File_temporal_server_api_persistence_v1_queue_metadata_proto = out.File
  
  127
  >
  	file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes = nil
  
  128
  >
  	file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs = nil
  
  129
  
  }

go.temporal.io/server/api/persistence/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  846
  
  }
  
  847
  
  848
  >
  func init() { file_temporal_server_api_persistence_v1_tasks_proto_init() }
  
tasks.pb.go

  849
  >
  func file_temporal_server_api_persistence_v1_tasks_proto_init() {
  
  850
  >
  	if File_temporal_server_api_persistence_v1_tasks_proto != nil {
  
  851
  
  		return
  
  852
  
  	}
  
  853
  >
  	type x struct{}
  
tasks.pb.go

  854
  >
  	out := protoimpl.TypeBuilder{
  
  855
  >
  		File: protoimpl.DescBuilder{
  
  856
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  857
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc), len(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc)),
  
  858
  >
  			NumEnums:      0,
  
  859
  >
  			NumMessages:   8,
  
  860
  >
  			NumExtensions: 0,
  
  861
  >
  			NumServices:   0,
  
  862
  >
  		},
  
  863
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_tasks_proto_goTypes,
  
  864
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_tasks_proto_depIdxs,
  
  865
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_tasks_proto_msgTypes,
  
  866
  >
  	}.Build()
  
  867
  >
  	File_temporal_server_api_persistence_v1_tasks_proto = out.File
  
  868
  >
  	file_temporal_server_api_persistence_v1_tasks_proto_goTypes = nil
  
  869
  >
  	file_temporal_server_api_persistence_v1_tasks_proto_depIdxs = nil
  
  870
  
  }

go.temporal.io/server/api/token/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  785
  
  }
  
  786
  
  787
  >
  func init() { file_temporal_server_api_token_v1_message_proto_init() }
  
message.pb.go

  788
  >
  func file_temporal_server_api_token_v1_message_proto_init() {
  
  789
  >
  	if File_temporal_server_api_token_v1_message_proto != nil {
  
  790
  
  		return
  
  791
  
  	}
  
  792
  >
  	type x struct{}
  
message.pb.go

  793
  >
  	out := protoimpl.TypeBuilder{
  
  794
  >
  		File: protoimpl.DescBuilder{
  
  795
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  796
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_token_v1_message_proto_rawDesc), len(file_temporal_server_api_token_v1_message_proto_rawDesc)),
  
  797
  >
  			NumEnums:      0,
  
  798
  >
  			NumMessages:   7,
  
  799
  >
  			NumExtensions: 0,
  
  800
  >
  			NumServices:   0,
  
  801
  >
  		},
  
  802
  >
  		GoTypes:           file_temporal_server_api_token_v1_message_proto_goTypes,
  
  803
  >
  		DependencyIndexes: file_temporal_server_api_token_v1_message_proto_depIdxs,
  
  804
  >
  		MessageInfos:      file_temporal_server_api_token_v1_message_proto_msgTypes,
  
  805
  >
  	}.Build()
  
  806
  >
  	File_temporal_server_api_token_v1_message_proto = out.File
  
  807
  >
  	file_temporal_server_api_token_v1_message_proto_goTypes = nil
  
  808
  >
  	file_temporal_server_api_token_v1_message_proto_depIdxs = nil
  
  809
  
  }

go.temporal.io/server/api/visibilityservice/v1/request_response.pb.go 20 covered LOC · 2 ranges

Open complete file

  402
  
  }
  
  403
  
  404
  >
  func init() { file_temporal_server_api_visibilityservice_v1_request_response_proto_init() }
  
request_response.pb.go

  405
  >
  func file_temporal_server_api_visibilityservice_v1_request_response_proto_init() {
  
  406
  >
  	if File_temporal_server_api_visibilityservice_v1_request_response_proto != nil {
  
  407
  
  		return
  
  408
  
  	}
  
  409
  >
  	type x struct{}
  
request_response.pb.go

  410
  >
  	out := protoimpl.TypeBuilder{
  
  411
  >
  		File: protoimpl.DescBuilder{
  
  412
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  413
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc)),
  
  414
  >
  			NumEnums:      0,
  
  415
  >
  			NumMessages:   5,
  
  416
  >
  			NumExtensions: 0,
  
  417
  >
  			NumServices:   0,
  
  418
  >
  		},
  
  419
  >
  		GoTypes:           file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes,
  
  420
  >
  		DependencyIndexes: file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs,
  
  421
  >
  		MessageInfos:      file_temporal_server_api_visibilityservice_v1_request_response_proto_msgTypes,
  
  422
  >
  	}.Build()
  
  423
  >
  	File_temporal_server_api_visibilityservice_v1_request_response_proto = out.File
  
  424
  >
  	file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes = nil
  
  425
  >
  	file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs = nil
  
  426
  
  }

go.temporal.io/server/api/workflow/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  278
  
  }
  
  279
  
  280
  >
  func init() { file_temporal_server_api_workflow_v1_message_proto_init() }
  
message.pb.go

  281
  >
  func file_temporal_server_api_workflow_v1_message_proto_init() {
  
  282
  >
  	if File_temporal_server_api_workflow_v1_message_proto != nil {
  
  283
  
  		return
  
  284
  
  	}
  
  285
  >
  	type x struct{}
  
message.pb.go

  286
  >
  	out := protoimpl.TypeBuilder{
  
  287
  >
  		File: protoimpl.DescBuilder{
  
  288
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  289
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_workflow_v1_message_proto_rawDesc), len(file_temporal_server_api_workflow_v1_message_proto_rawDesc)),
  
  290
  >
  			NumEnums:      0,
  
  291
  >
  			NumMessages:   3,
  
  292
  >
  			NumExtensions: 0,
  
  293
  >
  			NumServices:   0,
  
  294
  >
  		},
  
  295
  >
  		GoTypes:           file_temporal_server_api_workflow_v1_message_proto_goTypes,
  
  296
  >
  		DependencyIndexes: file_temporal_server_api_workflow_v1_message_proto_depIdxs,
  
  297
  >
  		MessageInfos:      file_temporal_server_api_workflow_v1_message_proto_msgTypes,
  
  298
  >
  	}.Build()
  
  299
  >
  	File_temporal_server_api_workflow_v1_message_proto = out.File
  
  300
  >
  	file_temporal_server_api_workflow_v1_message_proto_goTypes = nil
  
  301
  >
  	file_temporal_server_api_workflow_v1_message_proto_depIdxs = nil
  
  302
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  91
  
  }
  
  92
  
  93
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() }
  
service.pb.go

  94
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() {
  
  95
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_service_proto != nil {
  
  96
  
  		return
  
  97
  
  	}
  
  98
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init()
  
service.pb.go

  99
  >
  	type x struct{}
  
  100
  >
  	out := protoimpl.TypeBuilder{
  
  101
  >
  		File: protoimpl.DescBuilder{
  
  102
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  103
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc)),
  
  104
  >
  			NumEnums:      0,
  
  105
  >
  			NumMessages:   0,
  
  106
  >
  			NumExtensions: 0,
  
  107
  >
  			NumServices:   1,
  
  108
  >
  		},
  
  109
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes,
  
  110
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs,
  
  111
  >
  	}.Build()
  
  112
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_service_proto = out.File
  
  113
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = nil
  
  114
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = nil
  
  115
  
  }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  148
  
  }
  
  149
  
  150
  >
  func init() { file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  151
  >
  func file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() {
  
  152
  >
  	if File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto != nil {
  
  153
  
  		return
  
  154
  
  	}
  
  155
  >
  	type x struct{}
  
tasks.pb.go

  156
  >
  	out := protoimpl.TypeBuilder{
  
  157
  >
  		File: protoimpl.DescBuilder{
  
  158
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  159
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc)),
  
  160
  >
  			NumEnums:      0,
  
  161
  >
  			NumMessages:   2,
  
  162
  >
  			NumExtensions: 0,
  
  163
  >
  			NumServices:   0,
  
  164
  >
  		},
  
  165
  >
  		GoTypes:           file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes,
  
  166
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs,
  
  167
  >
  		MessageInfos:      file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_msgTypes,
  
  168
  >
  	}.Build()
  
  169
  >
  	File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto = out.File
  
  170
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes = nil
  
  171
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs = nil
  
  172
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  71
  
  }
  
  72
  
  73
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() }
  
service.pb.go

  74
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() {
  
  75
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto != nil {
  
  76
  
  		return
  
  77
  
  	}
  
  78
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init()
  
service.pb.go

  79
  >
  	type x struct{}
  
  80
  >
  	out := protoimpl.TypeBuilder{
  
  81
  >
  		File: protoimpl.DescBuilder{
  
  82
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  83
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc)),
  
  84
  >
  			NumEnums:      0,
  
  85
  >
  			NumMessages:   0,
  
  86
  >
  			NumExtensions: 0,
  
  87
  >
  			NumServices:   1,
  
  88
  >
  		},
  
  89
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes,
  
  90
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs,
  
  91
  >
  	}.Build()
  
  92
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto = out.File
  
  93
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes = nil
  
  94
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs = nil
  
  95
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  354
  
  }
  
  355
  
  356
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  357
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() {
  
  358
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto != nil {
  
  359
  
  		return
  
  360
  
  	}
  
  361
  >
  	type x struct{}
  
tasks.pb.go

  362
  >
  	out := protoimpl.TypeBuilder{
  
  363
  >
  		File: protoimpl.DescBuilder{
  
  364
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  365
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc)),
  
  366
  >
  			NumEnums:      0,
  
  367
  >
  			NumMessages:   7,
  
  368
  >
  			NumExtensions: 0,
  
  369
  >
  			NumServices:   0,
  
  370
  >
  		},
  
  371
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes,
  
  372
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs,
  
  373
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_msgTypes,
  
  374
  >
  	}.Build()
  
  375
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto = out.File
  
  376
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes = nil
  
  377
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs = nil
  
  378
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  86
  
  }
  
  87
  
  88
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() }
  
service.pb.go

  89
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() {
  
  90
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto != nil {
  
  91
  
  		return
  
  92
  
  	}
  
  93
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init()
  
service.pb.go

  94
  >
  	type x struct{}
  
  95
  >
  	out := protoimpl.TypeBuilder{
  
  96
  >
  		File: protoimpl.DescBuilder{
  
  97
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  98
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc)),
  
  99
  >
  			NumEnums:      0,
  
  100
  >
  			NumMessages:   0,
  
  101
  >
  			NumExtensions: 0,
  
  102
  >
  			NumServices:   1,
  
  103
  >
  		},
  
  104
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes,
  
  105
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs,
  
  106
  >
  	}.Build()
  
  107
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto = out.File
  
  108
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes = nil
  
  109
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs = nil
  
  110
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  343
  
  }
  
  344
  
  345
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  346
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() {
  
  347
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto != nil {
  
  348
  
  		return
  
  349
  
  	}
  
  350
  >
  	type x struct{}
  
tasks.pb.go

  351
  >
  	out := protoimpl.TypeBuilder{
  
  352
  >
  		File: protoimpl.DescBuilder{
  
  353
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  354
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc)),
  
  355
  >
  			NumEnums:      0,
  
  356
  >
  			NumMessages:   7,
  
  357
  >
  			NumExtensions: 0,
  
  358
  >
  			NumServices:   0,
  
  359
  >
  		},
  
  360
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes,
  
  361
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs,
  
  362
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_msgTypes,
  
  363
  >
  	}.Build()
  
  364
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto = out.File
  
  365
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes = nil
  
  366
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs = nil
  
  367
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  242
  
  }
  
  243
  
  244
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() }
  
message.pb.go

  245
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() {
  
  246
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_message_proto != nil {
  
  247
  
  		return
  
  248
  
  	}
  
  249
  >
  	type x struct{}
  
message.pb.go

  250
  >
  	out := protoimpl.TypeBuilder{
  
  251
  >
  		File: protoimpl.DescBuilder{
  
  252
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  253
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc)),
  
  254
  >
  			NumEnums:      0,
  
  255
  >
  			NumMessages:   4,
  
  256
  >
  			NumExtensions: 0,
  
  257
  >
  			NumServices:   0,
  
  258
  >
  		},
  
  259
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes,
  
  260
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs,
  
  261
  >
  		MessageInfos:      file_temporal_server_chasm_lib_tests_proto_v1_message_proto_msgTypes,
  
  262
  >
  	}.Build()
  
  263
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_message_proto = out.File
  
  264
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes = nil
  
  265
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs = nil
  
  266
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  46
  
  }
  
  47
  
  48
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() }
  
service.pb.go

  49
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() {
  
  50
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_service_proto != nil {
  
  51
  
  		return
  
  52
  
  	}
  
  53
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init()
  
service.pb.go

  54
  >
  	type x struct{}
  
  55
  >
  	out := protoimpl.TypeBuilder{
  
  56
  >
  		File: protoimpl.DescBuilder{
  
  57
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  58
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc)),
  
  59
  >
  			NumEnums:      0,
  
  60
  >
  			NumMessages:   0,
  
  61
  >
  			NumExtensions: 0,
  
  62
  >
  			NumServices:   1,
  
  63
  >
  		},
  
  64
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes,
  
  65
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs,
  
  66
  >
  	}.Build()
  
  67
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_service_proto = out.File
  
  68
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes = nil
  
  69
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs = nil
  
  70
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/state.pb.go 20 covered LOC · 2 ranges

Open complete file

  211
  
  }
  
  212
  
  213
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() }
  
state.pb.go

  214
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() {
  
  215
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_state_proto != nil {
  
  216
  
  		return
  
  217
  
  	}
  
  218
  >
  	type x struct{}
  
state.pb.go

  219
  >
  	out := protoimpl.TypeBuilder{
  
  220
  >
  		File: protoimpl.DescBuilder{
  
  221
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  222
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc)),
  
  223
  >
  			NumEnums:      0,
  
  224
  >
  			NumMessages:   3,
  
  225
  >
  			NumExtensions: 0,
  
  226
  >
  			NumServices:   0,
  
  227
  >
  		},
  
  228
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes,
  
  229
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs,
  
  230
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_msgTypes,
  
  231
  >
  	}.Build()
  
  232
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_state_proto = out.File
  
  233
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes = nil
  
  234
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs = nil
  
  235
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/update_state.pb.go 20 covered LOC · 2 ranges

Open complete file

  113
  
  }
  
  114
  
  115
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() }
  
update_state.pb.go

  116
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() {
  
  117
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto != nil {
  
  118
  
  		return
  
  119
  
  	}
  
  120
  >
  	type x struct{}
  
update_state.pb.go

  121
  >
  	out := protoimpl.TypeBuilder{
  
  122
  >
  		File: protoimpl.DescBuilder{
  
  123
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  124
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc)),
  
  125
  >
  			NumEnums:      0,
  
  126
  >
  			NumMessages:   1,
  
  127
  >
  			NumExtensions: 0,
  
  128
  >
  			NumServices:   0,
  
  129
  >
  		},
  
  130
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes,
  
  131
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs,
  
  132
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_msgTypes,
  
  133
  >
  	}.Build()
  
  134
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto = out.File
  
  135
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes = nil
  
  136
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs = nil
  
  137
  
  }

go.temporal.io/server/common/log/tag/zap_tag.go 20 covered LOC · 4 ranges

Open complete file

  44
  
  }
  
  45
  
  46
  >
  func NewStringTag(key string, value string) ZapTag {
  
zap_tag.go

  47
  >
  	return ZapTag{
  
  48
  >
  		field: zap.String(key, value),
  
  49
  >
  	}
  
  50
  >
  }
  
  51
  
  52
  
  func NewStringsTag(key string, value []string) ZapTag {

  82
  
  }
  
  83
  
  84
  >
  func NewInt64(key string, value int64) ZapTag {
  
zap_tag.go

  85
  >
  	return ZapTag{
  
  86
  >
  		field: zap.Int64(key, value),
  
  87
  >
  	}
  
  88
  >
  }
  
  89
  
  90
  
  func NewInt(key string, value int) ZapTag {

  118
  
  }
  
  119
  
  120
  >
  func NewBoolTag(key string, value bool) ZapTag {
  
zap_tag.go

  121
  >
  	return ZapTag{
  
  122
  >
  		field: zap.Bool(key, value),
  
  123
  >
  	}
  
  124
  >
  }
  
  125
  
  126
  
  func NewErrorTag(key string, value error) ZapTag {

  154
  
  }
  
  155
  
  156
  >
  func NewAnyTag(key string, value any) ZapTag {
  
zap_tag.go

  157
  >
  	return ZapTag{
  
  158
  >
  		field: zap.Any(key, value),
  
  159
  >
  	}
  
  160
  >
  }
  
  161
  
  162
  
  func NewBinaryTag(key string, value []byte) ZapTag {

go.temporal.io/server/common/util/wildcard.go 20 covered LOC · 7 ranges

Open complete file

  18
  
  // WildCardStringToRegexps converts a given slices of string patterns to a slice of regular expressions matching
  
  19
  
  // wildcards (*) with any substring.
  
  20
  >
  func WildCardStringsToRegexp(patterns []string) (*regexp.Regexp, error) {
  
wildcard.go

  21
  >
  	var result strings.Builder
  
  22
  >
  	result.WriteRune('^')
  
  23
  >
  	for i, pattern := range patterns {
  
  24
  >
  		result.WriteRune('(')
  
  25
  >
  		first := true
  
  26
  >
  		for literal := range strings.SplitSeq(pattern, "*") {
  
  27
  >
  			if !first {
  
  28
  
  				// Replace * with .*
  
  29
  
  				result.WriteString(".*")
  
  30
  
  			}
  
  31
  >
  			result.WriteString(regexp.QuoteMeta(literal))
  
wildcard.go

  32
  >
  			first = false
  
  33
  
  		}
  
  34
  >
  		result.WriteRune(')')
  
wildcard.go

  35
  >
  		if i < len(patterns)-1 {
  
  36
  >
  			result.WriteRune('|')
  
wildcard.go

  37
  >
  		}
  
  38
  
  	}
  
  39
  >
  	result.WriteRune('$')
  
wildcard.go

  40
  >
  	return regexp.Compile(result.String())
  
  41
  
  }
  
  42
  
  43
  
  // MustWildCardStringsToRegexp is like WildCardStringsToRegexp but panics on error.
  
  44
  >
  func MustWildCardStringsToRegexp(patterns []string) *regexp.Regexp {
  
wildcard.go

  45
  >
  	re, err := WildCardStringsToRegexp(patterns)
  
  46
  >
  	if err != nil {
  
  47
  
  		panic(err) //nolint:forbidigo // Must* functions conventionally panic on error.
  
  48
  
  	}
  
  49
  >
  	return re
  
wildcard.go

  50
  
  }

go.temporal.io/server/service/history/workflow/cache/cache_mock.go 20 covered LOC · 4 ranges

Open complete file

  35
  
  36
  
  // NewMockCache creates a new mock instance.
  
  37
  >
  func NewMockCache(ctrl *gomock.Controller) *MockCache {
  
cache_mock.go

  38
  >
  	mock := &MockCache{ctrl: ctrl}
  
  39
  >
  	mock.recorder = &MockCacheMockRecorder{mock}
  
  40
  >
  	return mock
  
  41
  >
  }
  
  42
  
  43
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  44
  >
  func (m *MockCache) EXPECT() *MockCacheMockRecorder {
  
cache_mock.go

  45
  >
  	return m.recorder
  
  46
  >
  }
  
  47
  
  48
  
  // GetOrCreateChasmExecution mocks base method.
  
  49
  >
  func (m *MockCache) GetOrCreateChasmExecution(ctx context.Context, shardContext interfaces.ShardContext, namespaceID namespace.ID, execution *common.WorkflowExecution, archetypeID chasm.ArchetypeID, lockPriority locks.Priority) (interfaces.WorkflowContext, interfaces.ReleaseWorkflowContextFunc, error) {
  
cache_mock.go

  50
  >
  	m.ctrl.T.Helper()
  
  51
  >
  	ret := m.ctrl.Call(m, "GetOrCreateChasmExecution", ctx, shardContext, namespaceID, execution, archetypeID, lockPriority)
  
  52
  >
  	ret0, _ := ret[0].(interfaces.WorkflowContext)
  
  53
  >
  	ret1, _ := ret[1].(interfaces.ReleaseWorkflowContextFunc)
  
  54
  >
  	ret2, _ := ret[2].(error)
  
  55
  >
  	return ret0, ret1, ret2
  
  56
  >
  }
  
  57
  
  58
  
  // GetOrCreateChasmExecution indicates an expected call of GetOrCreateChasmExecution.
  
  59
  >
  func (mr *MockCacheMockRecorder) GetOrCreateChasmExecution(ctx, shardContext, namespaceID, execution, archetypeID, lockPriority any) *gomock.Call {
  
cache_mock.go

  60
  >
  	mr.mock.ctrl.T.Helper()
  
  61
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateChasmExecution", reflect.TypeOf((*MockCache)(nil).GetOrCreateChasmExecution), ctx, shardContext, namespaceID, execution, archetypeID, lockPriority)
  
  62
  >
  }
  
  63
  
  64
  
  // GetOrCreateCurrentExecution mocks base method.

go.temporal.io/server/service/history/archival/archiver_mock.go 19 covered LOC · 4 ranges

Open complete file

  30
  
  31
  
  // NewMockArchiver creates a new mock instance.
  
  32
  >
  func NewMockArchiver(ctrl *gomock.Controller) *MockArchiver {
  
archiver_mock.go

  33
  >
  	mock := &MockArchiver{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockArchiverMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockArchiver) EXPECT() *MockArchiverMockRecorder {
  
archiver_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // Archive mocks base method.
  
  44
  >
  func (m *MockArchiver) Archive(arg0 context.Context, arg1 *Request) (*Response, error) {
  
archiver_mock.go

  45
  >
  	m.ctrl.T.Helper()
  
  46
  >
  	ret := m.ctrl.Call(m, "Archive", arg0, arg1)
  
  47
  >
  	ret0, _ := ret[0].(*Response)
  
  48
  >
  	ret1, _ := ret[1].(error)
  
  49
  >
  	return ret0, ret1
  
  50
  >
  }
  
  51
  
  52
  
  // Archive indicates an expected call of Archive.
  
  53
  >
  func (mr *MockArchiverMockRecorder) Archive(arg0, arg1 any) *gomock.Call {
  
archiver_mock.go

  54
  >
  	mr.mock.ctrl.T.Helper()
  
  55
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Archive", reflect.TypeOf((*MockArchiver)(nil).Archive), arg0, arg1)
  
  56
  >
  }

go.temporal.io/server/service/history/interfaces/workflow_context_mock.go 19 covered LOC · 4 ranges

Open complete file

  38
  
  39
  
  // NewMockWorkflowContext creates a new mock instance.
  
  40
  >
  func NewMockWorkflowContext(ctrl *gomock.Controller) *MockWorkflowContext {
  
workflow_context_mock.go

  41
  >
  	mock := &MockWorkflowContext{ctrl: ctrl}
  
  42
  >
  	mock.recorder = &MockWorkflowContextMockRecorder{mock}
  
  43
  >
  	return mock
  
  44
  >
  }
  
  45
  
  46
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  47
  >
  func (m *MockWorkflowContext) EXPECT() *MockWorkflowContextMockRecorder {
  
workflow_context_mock.go

  48
  >
  	return m.recorder
  
  49
  >
  }
  
  50
  
  51
  
  // AppendTaskCompletionPage mocks base method.

  176
  
  177
  
  // LoadMutableState mocks base method.
  
  178
  >
  func (m *MockWorkflowContext) LoadMutableState(ctx context.Context, shardContext ShardContext) (MutableState, error) {
  
workflow_context_mock.go

  179
  >
  	m.ctrl.T.Helper()
  
  180
  >
  	ret := m.ctrl.Call(m, "LoadMutableState", ctx, shardContext)
  
  181
  >
  	ret0, _ := ret[0].(MutableState)
  
  182
  >
  	ret1, _ := ret[1].(error)
  
  183
  >
  	return ret0, ret1
  
  184
  >
  }
  
  185
  
  186
  
  // LoadMutableState indicates an expected call of LoadMutableState.
  
  187
  >
  func (mr *MockWorkflowContextMockRecorder) LoadMutableState(ctx, shardContext any) *gomock.Call {
  
workflow_context_mock.go

  188
  >
  	mr.mock.ctrl.T.Helper()
  
  189
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMutableState", reflect.TypeOf((*MockWorkflowContext)(nil).LoadMutableState), ctx, shardContext)
  
  190
  >
  }
  
  191
  
  192
  
  // Lock mocks base method.

go.temporal.io/server/common/metrics/grpc.go 18 covered LOC · 6 ranges

Open complete file

  123
  
  124
  
  // getMetricsContext extracts metrics context from golang context.
  
  125
  >
  func getMetricsContext(ctx context.Context) *metricsContext {
  
grpc.go

  126
  >
  	metricsCtx := ctx.Value(metricsCtxKey)
  
  127
  >
  	if metricsCtx == nil {
  
  128
  
  		return nil
  
  129
  
  	}
  
  130
  
  131
  >
  	return metricsCtx.(*metricsContext)
  
grpc.go

  132
  
  }
  
  133
  
  134
  >
  func AddMetricsContext(ctx context.Context) context.Context {
  
grpc.go

  135
  >
  	metricsCtx := &metricsContext{}
  
  136
  >
  	return context.WithValue(ctx, metricsCtxKey, metricsCtx)
  
  137
  >
  }
  
  138
  
  139
  
  // ContextCounterAdd adds value to counter within metrics context.

  160
  
  161
  
  // ContextCounterGet returns value and true if successfully retrieved value
  
  162
  >
  func ContextCounterGet(ctx context.Context, name string) (int64, bool) {
  
grpc.go

  163
  >
  	metricsCtx := getMetricsContext(ctx)
  
  164
  >
  
  165
  >
  	if metricsCtx == nil {
  
  166
  
  		return 0, false
  
  167
  
  	}
  
  168
  
  169
  >
  	metricsCtx.Lock()
  
grpc.go

  170
  >
  	defer metricsCtx.Unlock()
  
  171
  >
  
  172
  >
  	if metricsCtx.CountersInt == nil {
  
  173
  >
  		return 0, false
  
grpc.go

  174
  >
  	}
  
  175
  
  176
  
  	result, ok := metricsCtx.CountersInt[name]

go.temporal.io/server/common/namespace/replication_resolver.go 18 covered LOC · 3 ranges

Open complete file

  49
  
  }
  
  50
  
  51
  >
  func NewDefaultReplicationResolverFactory() ReplicationResolverFactory {
  
replication_resolver.go

  52
  >
  	return func(detail *persistencespb.NamespaceDetail) ReplicationResolver {
  
  53
  >
  		// By convention, a namespace with non-zero failover version is a global namespace
  
  54
  >
  		// This can be overridden by WithGlobalFlag mutation if needed
  
  55
  >
  		isGlobal := detail.FailoverVersion != 0
  
  56
  >
  		return &defaultReplicationResolver{
  
  57
  >
  			replicationConfig:           detail.ReplicationConfig,
  
  58
  >
  			isGlobalNamespace:           isGlobal,
  
  59
  >
  			failoverVersion:             detail.FailoverVersion,
  
  60
  >
  			failoverNotificationVersion: detail.FailoverNotificationVersion,
  
  61
  >
  		}
  
  62
  >
  	}
  
  63
  
  }
  
  64

  96
  
  }
  
  97
  
  98
  >
  func (r *defaultReplicationResolver) IsGlobalNamespace() bool {
  
replication_resolver.go

  99
  >
  	return r.isGlobalNamespace
  
  100
  >
  }
  
  101
  
  102
  
  func (r *defaultReplicationResolver) FailoverVersion(businessID string) int64 {

  112
  
  }
  
  113
  
  114
  >
  func (r *defaultReplicationResolver) SetGlobalFlag(isGlobal bool) {
  
replication_resolver.go

  115
  >
  	r.isGlobalNamespace = isGlobal
  
  116
  >
  }
  
  117
  
  118
  
  func (r *defaultReplicationResolver) SetActiveCluster(clusterName string) {

go.temporal.io/server/common/definition/workflow_key.go 16 covered LOC · 4 ranges

Open complete file

  19
  
  	workflowID string,
  
  20
  
  	runID string,
  
  21
  >
  ) WorkflowKey {
  
workflow_key.go

  22
  >
  	return WorkflowKey{
  
  23
  >
  		NamespaceID: namespaceID,
  
  24
  >
  		WorkflowID:  workflowID,
  
  25
  >
  		RunID:       runID,
  
  26
  >
  	}
  
  27
  >
  }
  
  28
  
  29
  >
  func (k *WorkflowKey) GetNamespaceID() string {
  
workflow_key.go

  30
  >
  	return k.NamespaceID
  
  31
  >
  }
  
  32
  
  33
  >
  func (k *WorkflowKey) GetWorkflowID() string {
  
workflow_key.go

  34
  >
  	return k.WorkflowID
  
  35
  >
  }
  
  36
  
  37
  >
  func (k *WorkflowKey) GetRunID() string {
  
workflow_key.go

  38
  >
  	return k.RunID
  
  39
  >
  }
  
  40
  
  41
  
  func (k *WorkflowKey) String() string {

go.temporal.io/server/service/history/workflow/relocatable_attributes_fetcher.go 16 covered LOC · 3 ranges

Open complete file

  33
  
  	config *configs.Config,
  
  34
  
  	visibilityManager manager.VisibilityManager,
  
  35
  >
  ) RelocatableAttributesFetcher {
  
relocatable_attributes_fetcher.go

  36
  >
  	return &relocatableAttributesFetcher{
  
  37
  >
  		visibilityManager:          visibilityManager,
  
  38
  >
  		disableFetchFromVisibility: config.DisableFetchRelocatableAttributesFromVisibility,
  
  39
  >
  	}
  
  40
  >
  }
  
  41
  
  42
  
  // RelocatableAttributes contains workflow attributes that can be moved from the mutable state to the persistence

  60
  
  	ctx context.Context,
  
  61
  
  	mutableState historyi.MutableState,
  
  62
  >
  ) (*RelocatableAttributes, error) {
  
relocatable_attributes_fetcher.go

  63
  >
  	executionInfo := mutableState.GetExecutionInfo()
  
  64
  >
  	// If the relocatable attributes were not removed from mutable state, then we can fetch the memo
  
  65
  >
  	// and search attributes from the mutable state.
  
  66
  >
  	if !executionInfo.GetRelocatableAttributesRemoved() {
  
  67
  >
  		return &RelocatableAttributes{
  
relocatable_attributes_fetcher.go

  68
  >
  			Memo:             &commonpb.Memo{Fields: executionInfo.Memo},
  
  69
  >
  			SearchAttributes: &commonpb.SearchAttributes{IndexedFields: executionInfo.SearchAttributes},
  
  70
  >
  		}, nil
  
  71
  >
  	}
  
  72
  
  73
  
  	if f.disableFetchFromVisibility(mutableState.GetNamespaceEntry().Name().String()) {

go.temporal.io/server/chasm/registry.go 15 covered LOC · 1 range

Open complete file

  51
  
  }
  
  52
  
  53
  >
  func NewRegistry(logger log.Logger) *Registry {
  
registry.go

  54
  >
  	return &Registry{
  
  55
  >
  		libraries:              make(map[string]Library),
  
  56
  >
  		rcByFqn:                make(map[string]*RegistrableComponent),
  
  57
  >
  		rcByID:                 make(map[uint32]*RegistrableComponent),
  
  58
  >
  		rcByGoType:             make(map[reflect.Type]*RegistrableComponent),
  
  59
  >
  		rtByFqn:                make(map[string]*RegistrableTask),
  
  60
  >
  		rtByID:                 make(map[uint32]*RegistrableTask),
  
  61
  >
  		rtByGoType:             make(map[reflect.Type]*RegistrableTask),
  
  62
  >
  		rcContextValues:        make(map[any]valueWithFqn),
  
  63
  >
  		nexusServices:          make(map[string]*nexus.Service),
  
  64
  >
  		NexusEndpointProcessor: NewNexusEndpointProcessor(),
  
  65
  >
  		logger:                 logger,
  
  66
  >
  	}
  
  67
  >
  }
  
  68
  
  69
  
  func (r *Registry) Register(lib Library) error {

go.temporal.io/server/common/persistence/visibility/store/sql/query_converter_util_legacy.go 15 covered LOC · 3 ranges

Open complete file

  68
  
  }
  
  69
  
  70
  >
  func newColName(name string) *colName {
  
query_converter_util_legacy.go

  71
  >
  	return &colName{Name: name}
  
  72
  >
  }
  
  73
  
  74
  
  func newSAColName(

  77
  
  	fieldName string,
  
  78
  
  	valueType enumspb.IndexedValueType,
  
  79
  >
  ) *saColName {
  
query_converter_util_legacy.go

  80
  >
  	return &saColName{
  
  81
  >
  		dbColName: newColName(dbColName),
  
  82
  >
  		alias:     alias,
  
  83
  >
  		fieldName: fieldName,
  
  84
  >
  		valueType: valueType,
  
  85
  >
  	}
  
  86
  >
  }
  
  87
  
  88
  
  func newFuncExpr(name string, exprs ...sqlparser.Expr) *sqlparser.FuncExpr {

  105
  
  }
  
  106
  
  107
  >
  func getMaxDatetimeValue() time.Time {
  
query_converter_util_legacy.go

  108
  >
  	t, _ := time.Parse(time.RFC3339, "9999-12-31T23:59:59Z")
  
  109
  >
  	return t
  
  110
  >
  }
  
  111
  
  112
  
  // formatComparisonExprStringForError formats comparison expression after

go.temporal.io/server/common/build/build.go 14 covered LOC · 2 ranges

Open complete file

  27
  
  )
  
  28
  
  29
  >
  func init() {
  
build.go

  30
  >
  	buildInfo, ok := debug.ReadBuildInfo()
  
  31
  >
  	if !ok {
  
  32
  
  		return
  
  33
  
  	}
  
  34
  
  35
  >
  	InfoData.Available = true
  
build.go

  36
  >
  	InfoData.GoVersion = buildInfo.GoVersion
  
  37
  >
  
  38
  >
  	for _, setting := range buildInfo.Settings {
  
  39
  >
  		switch setting.Key {
  
  40
  >
  		case "GOARCH":
  
  41
  >
  			InfoData.GoArch = setting.Value
  
  42
  >
  		case "GOOS":
  
  43
  >
  			InfoData.GoOs = setting.Value
  
  44
  >
  		case "CGO_ENABLED":
  
  45
  >
  			InfoData.CgoEnabled = setting.Value == "1"
  
  46
  
  		case "vcs.revision":
  
  47
  
  			InfoData.GitRevision = setting.Value

go.temporal.io/server/common/dynamicconfig/gradual_change.go 14 covered LOC · 3 ranges

Open complete file

  25
  
  // StaticGradualChange returns a GradualChange whose Value always returns def and whose When
  
  26
  
  // always returns a time in the past.
  
  27
  >
  func StaticGradualChange[T any](def T) GradualChange[T] {
  
gradual_change.go

  28
  >
  	return GradualChange[T]{New: def}
  
  29
  >
  }
  
  30
  
  31
  
  // Value returns the value for the given key at the given time.

  56
  
  // of type GradualChange into a GradualChange.
  
  57
  
  // nolint:revive // cognitive-complexity // this looks complicated but each case is fairly simple
  
  58
  >
  func ConvertGradualChange[T any](def T) func(v any) (GradualChange[T], error) {
  
gradual_change.go

  59
  >
  	changeConverter := ConvertStructure(StaticGradualChange(def))
  
  60
  >
  
  61
  >
  	// Call this once so that if it's going to panic, it panics at static init time.
  
  62
  >
  	_, _ = changeConverter(nil)
  
  63
  >
  
  64
  >
  	switch reflect.TypeFor[T]() {
  
  65
  >
  	case reflect.TypeFor[bool]():
  
  66
  >
  		return func(v any) (GradualChange[T], error) {
  
  67
  
  			if b, err := convertBool(v); err == nil {
  
  68
  
  				var change GradualChange[T]

  72
  
  			return changeConverter(v)
  
  73
  
  		}
  
  74
  >
  	case reflect.TypeFor[int]():
  
gradual_change.go

  75
  >
  		return func(v any) (GradualChange[T], error) {
  
  76
  
  			if i, err := convertInt(v); err == nil {
  
  77
  
  				var change GradualChange[T]

go.temporal.io/server/common/headers/caller_info.go 13 covered LOC · 2 ranges

Open complete file

  79
  
  func NewBackgroundHighCallerInfo(
  
  80
  
  	callerName string,
  
  81
  >
  ) CallerInfo {
  
caller_info.go

  82
  >
  	return CallerInfo{
  
  83
  >
  		CallerName: callerName,
  
  84
  >
  		CallerType: CallerTypeBackgroundHigh,
  
  85
  >
  	}
  
  86
  >
  }
  
  87
  
  88
  
  // NewBackgroundLowCallerInfo creates a new CallerInfo with BackgroundLow callerType

  117
  
  	ctx context.Context,
  
  118
  
  	info CallerInfo,
  
  119
  >
  ) context.Context {
  
caller_info.go

  120
  >
  	return setIncomingMD(ctx, map[string]string{
  
  121
  >
  		CallerNameHeaderName: info.CallerName,
  
  122
  >
  		CallerTypeHeaderName: info.CallerType,
  
  123
  >
  		CallOriginHeaderName: info.CallOrigin,
  
  124
  >
  	})
  
  125
  >
  }
  
  126
  
  127
  
  // SetCallerName set caller name in the context.

go.temporal.io/server/common/metrics/defs_base.go 13 covered LOC · 2 ranges

Open complete file

  10
  
  }
  
  11
  
  12
  >
  func newMetricDefinition(name string, opts ...Option) metricDefinition {
  
defs_base.go

  13
  >
  	d := metricDefinition{
  
  14
  >
  		name:        name,
  
  15
  >
  		description: "",
  
  16
  >
  		unit:        "",
  
  17
  >
  	}
  
  18
  >
  	for _, opt := range opts {
  
  19
  >
  		opt.apply(&d)
  
  20
  >
  	}
  
  21
  >
  	return d
  
  22
  
  }
  
  23
  
  24
  >
  func (md metricDefinition) Name() string {
  
defs_base.go

  25
  >
  	return md.name
  
  26
  >
  }
  
  27
  
  28
  
  func (md metricDefinition) Unit() MetricUnit {

go.temporal.io/server/common/metrics/noop_impl.go 12 covered LOC · 6 ranges

Open complete file

  15
  
  )
  
  16
  
  17
  >
  func newNoopMetricsHandler() *noopMetricsHandler { return &noopMetricsHandler{} }
  
noop_impl.go

  18
  
  19
  
  // WithTags creates a new MetricProvder with provided []Tag
  
  20
  
  // Tags are merged with registered Tags from the source MetricsHandler
  
  21
  >
  func (n *noopMetricsHandler) WithTags(...Tag) Handler {
  
noop_impl.go

  22
  >
  	return n
  
  23
  >
  }
  
  24
  
  25
  
  // Counter obtains a counter for the given name.
  
  26
  >
  func (*noopMetricsHandler) Counter(string) CounterIface {
  
noop_impl.go

  27
  >
  	return NoopCounterMetricFunc
  
  28
  >
  }
  
  29
  
  30
  
  // Gauge obtains a gauge for the given name.

  34
  
  35
  
  // Timer obtains a timer for the given name.
  
  36
  >
  func (*noopMetricsHandler) Timer(string) TimerIface {
  
noop_impl.go

  37
  >
  	return NoopTimerMetricFunc
  
  38
  >
  }
  
  39
  
  40
  
  // Histogram obtains a histogram for the given name.

  53
  
  }
  
  54
  
  55
  >
  var NoopCounterMetricFunc = CounterFunc(func(i int64, t ...Tag) {})
  
noop_impl.go

  56
  
  var NoopGaugeMetricFunc = GaugeFunc(func(f float64, t ...Tag) {})
  
  57
  >
  var NoopTimerMetricFunc = TimerFunc(func(d time.Duration, t ...Tag) {})
  
noop_impl.go

  58
  
  var NoopHistogramMetricFunc = HistogramFunc(func(i int64, t ...Tag) {})

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/visibility_store.go 12 covered LOC · 3 ranges

Open complete file

  101
  
  	}
  
  102
  
  103
  >
  	defaultSorter = func() []elastic.Sorter {
  
visibility_store.go

  104
  >
  		ret := make([]elastic.Sorter, 0, len(defaultSorterFields))
  
  105
  >
  		for _, item := range defaultSorterFields {
  
  106
  >
  			fs := elastic.NewFieldSort(item.name)
  
  107
  >
  			if item.desc {
  
  108
  >
  				fs.Desc()
  
  109
  >
  			}
  
  110
  >
  			if item.missing_first {
  
  111
  >
  				fs.Missing("_first")
  
  112
  >
  			} else {
  
  113
  
  				fs.Missing("_last")
  
  114
  
  			}
  
  115
  >
  			ret = append(ret, fs)
  
visibility_store.go

  116
  
  		}
  
  117
  >
  		return ret
  
visibility_store.go

  118
  
  	}()
  
  119

go.temporal.io/server/service/history/tasks/archive_execution_task.go 12 covered LOC · 4 ranges

Open complete file

  21
  
  )
  
  22
  
  23
  >
  func (a *ArchiveExecutionTask) GetKey() Key {
  
archive_execution_task.go

  24
  >
  	return NewKey(a.VisibilityTimestamp, a.TaskID)
  
  25
  >
  }
  
  26
  
  27
  
  func (a *ArchiveExecutionTask) GetTaskID() int64 {

  29
  
  }
  
  30
  
  31
  >
  func (a *ArchiveExecutionTask) GetVisibilityTime() time.Time {
  
archive_execution_task.go

  32
  >
  	return a.VisibilityTimestamp
  
  33
  >
  }
  
  34
  
  35
  >
  func (a *ArchiveExecutionTask) GetVersion() int64 {
  
archive_execution_task.go

  36
  >
  	return a.Version
  
  37
  >
  }
  
  38
  
  39
  >
  func (a *ArchiveExecutionTask) GetCategory() Category {
  
archive_execution_task.go

  40
  >
  	return CategoryArchival
  
  41
  >
  }
  
  42
  
  43
  
  func (a *ArchiveExecutionTask) GetType() enumsspb.TaskType {

go.temporal.io/server/service/history/ndc_task_util.go 11 covered LOC · 6 ranges

Open complete file

  37
  
  	taskVersion int64,
  
  38
  
  	task any,
  
  39
  >
  ) error {
  
ndc_task_util.go

  40
  >
  
  41
  >
  	if !shard.GetClusterMetadata().IsGlobalNamespaceEnabled() {
  
  42
  
  		return nil
  
  43
  
  	}
  
  44
  
  45
  
  	// the first return value is whether this task is valid for further processing
  
  46
  >
  	if !namespace.IsGlobalNamespace() {
  
ndc_task_util.go

  47
  
  		logger.Debug("NamespaceID is not global, task version check pass", tag.WorkflowNamespaceID(namespace.ID().String()), tag.Task(task))
  
  48
  
  		return nil
  
  49
  >
  	} else if version != taskVersion {
  
ndc_task_util.go

  50
  
  		logger.Debug("NamespaceID is global, task version != target version", tag.WorkflowNamespaceID(namespace.ID().String()), tag.Task(task), tag.TaskVersion(version))
  
  51
  
  		return consts.ErrTaskVersionMismatch
  
  52
  
  	}
  
  53
  >
  	logger.Debug("NamespaceID is global, task version == target version", tag.WorkflowNamespaceID(namespace.ID().String()), tag.Task(task), tag.TaskVersion(version))
  
ndc_task_util.go

  54
  >
  	return nil
  
  55
  
  }
  
  56

  309
  
  	registry namespace.Registry,
  
  310
  
  	namespaceID string,
  
  311
  >
  ) metrics.Tag {
  
ndc_task_util.go

  312
  >
  	namespaceName, err := registry.GetNamespaceName(namespace.ID(namespaceID))
  
  313
  >
  	if err != nil {
  
  314
  
  		return metrics.NamespaceUnknownTag()
  
  315
  
  	}
  
  316
  
  317
  >
  	return metrics.NamespaceTag(namespaceName.String())
  
ndc_task_util.go

  318
  
  }
  
  319

go.temporal.io/server/service/history/tests/vars.go 11 covered LOC · 1 range

Open complete file

  158
  
  )
  
  159
  
  160
  >
  func NewDynamicConfig() *configs.Config {
  
vars.go

  161
  >
  	dc := dynamicconfig.NewNoopCollection()
  
  162
  >
  	config := configs.NewConfig(dc, 1)
  
  163
  >
  	config.EnableActivityEagerExecution = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  164
  >
  	config.NamespaceCacheRefreshInterval = dynamicconfig.GetDurationPropertyFn(time.Second)
  
  165
  >
  	config.ReplicationEnableUpdateWithNewTaskMerge = dynamicconfig.GetBoolPropertyFn(true)
  
  166
  >
  	config.EnableWorkflowIdReuseStartTimeValidation = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  167
  >
  	config.EnableTransitionHistory = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  168
  >
  	config.EnableChasm = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(false)
  
  169
  >
  	return config
  
  170
  >
  }

go.temporal.io/server/common/headers/headers.go 10 covered LOC · 4 ranges

Open complete file

  154
  
  // setIncomingMD sets the key-value pairs in the incoming metadata.
  
  155
  
  // Empty values are ignored.
  
  156
  >
  func setIncomingMD(ctx context.Context, kv map[string]string) context.Context {
  
headers.go

  157
  >
  	mdIncoming, ok := metadata.FromIncomingContext(ctx)
  
  158
  >
  	if !ok {
  
  159
  >
  		mdIncoming = metadata.MD{}
  
headers.go

  160
  >
  	}
  
  161
  >
  	for k, v := range kv {
  
headers.go

  162
  >
  		if v != "" {
  
  163
  >
  			mdIncoming.Set(k, v)
  
  164
  >
  		}
  
  165
  
  	}
  
  166
  >
  	return metadata.NewIncomingContext(ctx, mdIncoming)
  
headers.go

  167
  
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/plugin.go 10 covered LOC · 1 range

Open complete file

  36
  
  var _ sqlplugin.Plugin = (*plugin)(nil)
  
  37
  
  38
  >
  func init() {
  
plugin.go

  39
  >
  	sql.RegisterPlugin(PluginName, &plugin{
  
  40
  >
  		driver:         &driver.PQDriver{},
  
  41
  >
  		queryConverter: &queryConverter{},
  
  42
  >
  	})
  
  43
  >
  	sql.RegisterPlugin(PluginNamePGX, &plugin{
  
  44
  >
  		driver:         &driver.PGXDriver{},
  
  45
  >
  		queryConverter: &queryConverter{},
  
  46
  >
  	})
  
  47
  >
  }
  
  48
  
  49
  
  func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/visibility.go 10 covered LOC · 1 range

Open complete file

  40
  
  )
  
  41
  
  42
  >
  func buildOnDuplicateKeyUpdate(fields ...string) string {
  
visibility.go

  43
  >
  	items := make([]string, len(fields))
  
  44
  >
  	for i, field := range fields {
  
  45
  >
  		items[i] = fmt.Sprintf("%s = excluded.%s", field, field)
  
  46
  >
  	}
  
  47
  >
  	return fmt.Sprintf(
  
  48
  >
  		// The WHERE clause ensures that no update occurs if the version is behind the saved version.
  
  49
  >
  		"ON CONFLICT (namespace_id, run_id) DO UPDATE SET %s WHERE executions_visibility.%s < EXCLUDED.%s",
  
  50
  >
  		strings.Join(items, ", "), sqlplugin.VersionColumnName, sqlplugin.VersionColumnName,
  
  51
  >
  	)
  
  52
  
  }
  
  53

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/visibility.go 10 covered LOC · 1 range

Open complete file

  42
  
  )
  
  43
  
  44
  >
  func buildOnDuplicateKeyUpdate(fields ...string) string {
  
visibility.go

  45
  >
  	items := make([]string, len(fields))
  
  46
  >
  	for i, field := range fields {
  
  47
  >
  		items[i] = fmt.Sprintf("%s = excluded.%s", field, field)
  
  48
  >
  	}
  
  49
  >
  	return fmt.Sprintf(
  
  50
  >
  		// The WHERE clause ensures that no update occurs if the version is behind the saved version.
  
  51
  >
  		"ON CONFLICT (namespace_id, run_id) DO UPDATE SET %s WHERE executions_visibility.%s < EXCLUDED.%s",
  
  52
  >
  		strings.Join(items, ", "), sqlplugin.VersionColumnName, sqlplugin.VersionColumnName,
  
  53
  >
  	)
  
  54
  
  }
  
  55

go.temporal.io/server/common/persistence/sql/sqlplugin/visibility.go 10 covered LOC · 2 ranges

Open complete file

  219
  
  }
  
  220
  
  221
  >
  func getDbFields() []string {
  
visibility.go

  222
  >
  	t := reflect.TypeFor[VisibilityRow]()
  
  223
  >
  	dbFields := make([]string, t.NumField())
  
  224
  >
  	for i := 0; i < t.NumField(); i++ {
  
  225
  >
  		f := t.Field(i)
  
  226
  >
  		dbFields[i] = f.Tag.Get("db")
  
  227
  >
  		if dbFields[i] == "" {
  
  228
  >
  			dbFields[i] = strcase.ToSnake(f.Name)
  
  229
  >
  		}
  
  230
  
  	}
  
  231
  >
  	return dbFields
  
visibility.go

  232
  
  }
  
  233

go.temporal.io/server/common/persistence/visibility/store/query/util.go 10 covered LOC · 2 ranges

Open complete file

  70
  
  }
  
  71
  
  72
  >
  func NewUnsafeSQLString(val string) *UnsafeSQLString {
  
util.go

  73
  >
  	return &UnsafeSQLString{Val: val}
  
  74
  >
  }
  
  75
  
  76
  
  func NewColName(name string) *ColumnName {

  78
  
  }
  
  79
  
  80
  >
  func NewSAColumn(alias string, fieldName string, valueType enumspb.IndexedValueType) *SAColumn {
  
util.go

  81
  >
  	return &SAColumn{
  
  82
  >
  		Alias:     alias,
  
  83
  >
  		FieldName: fieldName,
  
  84
  >
  		ValueType: valueType,
  
  85
  >
  	}
  
  86
  >
  }
  
  87
  
  88
  
  func NamespaceDivisionSAColumn() *SAColumn {

go.temporal.io/server/common/dynamicconfig/static_client.go 9 covered LOC · 4 ranges

Open complete file

  10
  
  )
  
  11
  
  12
  >
  func (s StaticClient) GetValue(key Key) []ConstrainedValue {
  
static_client.go

  13
  >
  	if v, ok := s[key]; ok {
  
  14
  
  		if cvs, ok := v.([]ConstrainedValue); ok {
  
  15
  
  			return cvs

  17
  
  		return []ConstrainedValue{{Value: v}}
  
  18
  
  	}
  
  19
  >
  	return nil
  
static_client.go

  20
  
  }
  
  21
  
  22
  
  // NewNoopClient returns a Client that has no keys (a Collection using it will always return
  
  23
  
  // default values).
  
  24
  >
  func NewNoopClient() Client {
  
static_client.go

  25
  >
  	return StaticClient(nil)
  
  26
  >
  }
  
  27
  
  28
  
  // NewNoopCollection creates a new noop collection.
  
  29
  >
  func NewNoopCollection() *Collection {
  
static_client.go

  30
  >
  	return NewCollection(NewNoopClient(), log.NewNoopLogger())
  
  31
  >
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/util.go 9 covered LOC · 2 ranges

Open complete file

  5
  
  )
  
  6
  
  7
  >
  func appendPrefix(prefix string, fields []string) []string {
  
util.go

  8
  >
  	out := make([]string, len(fields))
  
  9
  >
  	for i, field := range fields {
  
  10
  >
  		out[i] = prefix + field
  
  11
  >
  	}
  
  12
  >
  	return out
  
  13
  
  }
  
  14
  
  15
  >
  func BuildNamedPlaceholder(fields ...string) string {
  
util.go

  16
  >
  	return strings.Join(appendPrefix(":", fields), ", ")
  
  17
  >
  }

go.temporal.io/server/common/primitives/timestamp/duration.go 9 covered LOC · 3 ranges

Open complete file

  26
  
  }
  
  27
  
  28
  >
  func DurationPtr(td time.Duration) *durationpb.Duration {
  
duration.go

  29
  >
  	return durationpb.New(td)
  
  30
  >
  }
  
  31
  
  32
  
  func MinDurationPtr(d1 *durationpb.Duration, d2 *durationpb.Duration) *durationpb.Duration {

  47
  
  }
  
  48
  
  49
  >
  func DurationFromDays(d int32) *durationpb.Duration {
  
duration.go

  50
  >
  	return durationMultipleOf(int64(d), time.Hour*24)
  
  51
  >
  }
  
  52
  
  53
  >
  func durationMultipleOf(amt int64, mult time.Duration) *durationpb.Duration {
  
duration.go

  54
  >
  	return DurationPtr(time.Duration(amt) * mult)
  
  55
  >
  }
  
  56
  
  57
  
  // ValidateAndCapProtoDuration validates protobuf durations for two conditions:

go.temporal.io/server/common/testing/testhooks/test_impl.go 9 covered LOC · 2 ranges

Open complete file

  89
  
  var keyCounter atomic.Int64
  
  90
  
  91
  >
  func newKey[T any, S any]() Key[T, S] {
  
test_impl.go

  92
  >
  	var zero S
  
  93
  >
  	var s ScopeType
  
  94
  >
  	switch any(zero).(type) {
  
  95
  >
  	case namespace.ID, namespace.Name:
  
  96
  >
  		s = ScopeNamespace
  
  97
  >
  	case global:
  
  98
  >
  		s = ScopeGlobal
  
  99
  
  	default:
  
  100
  
  		panic("testhooks: unknown scope type")
  
  101
  
  	}
  
  102
  >
  	return Key[T, S]{id: keyCounter.Add(1), scopeType: s}
  
test_impl.go

  103
  
  }

go.temporal.io/server/common/util/util.go 9 covered LOC · 3 ranges

Open complete file

  20
  
  21
  
  // MaxTime returns the latest of the given time.Time values.
  
  22
  >
  func MaxTime(first time.Time, rest ...time.Time) time.Time {
  
util.go

  23
  >
  	latest := first
  
  24
  >
  	for _, t := range rest {
  
  25
  >
  		if t.After(latest) {
  
  26
  
  			latest = t
  
  27
  
  		}
  
  28
  
  	}
  
  29
  >
  	return latest
  
util.go

  30
  
  }
  
  31

  68
  
  69
  
  // InverseMap creates the inverse map, ie., for a key-value map, it builds the value-key map.
  
  70
  >
  func InverseMap[M ~map[K]V, K, V comparable](m M) map[V]K {
  
util.go

  71
  >
  	if m == nil {
  
  72
  >
  		return nil
  
  73
  >
  	}
  
  74
  
  	invm := make(map[V]K, len(m))
  
  75
  
  	for k, v := range m {

go.temporal.io/server/service/history/queues/priority_assigner.go 9 covered LOC · 3 ranges

Open complete file

  65
  
  }
  
  66
  
  67
  >
  func NewNoopPriorityAssigner() PriorityAssigner {
  
priority_assigner.go

  68
  >
  	return NewStaticPriorityAssigner(tasks.PriorityHigh)
  
  69
  >
  }
  
  70
  
  71
  >
  func NewStaticPriorityAssigner(priority tasks.Priority) PriorityAssigner {
  
priority_assigner.go

  72
  >
  	return staticPriorityAssigner{priority: priority}
  
  73
  >
  }
  
  74
  
  75
  >
  func (a staticPriorityAssigner) Assign(_ Executable) tasks.Priority {
  
priority_assigner.go

  76
  >
  	return a.priority
  
  77
  >
  }

go.temporal.io/server/common/namespace/mutate.go 8 covered LOC · 2 ranges

Open complete file

  8
  
  type mutationFunc func(*Namespace)
  
  9
  
  10
  >
  func (f mutationFunc) apply(ns *Namespace) {
  
mutate.go

  11
  >
  	f(ns)
  
  12
  >
  }
  
  13
  
  14
  
  // WithActiveCluster assigns the active cluster to a Namespace during a Clone

  43
  
  44
  
  // WithGlobalFlag sets whether or not this Namespace is global.
  
  45
  >
  func WithGlobalFlag(b bool) Mutation {
  
mutate.go

  46
  >
  	return mutationFunc(
  
  47
  >
  		func(ns *Namespace) {
  
  48
  >
  			ns.replicationResolver.SetGlobalFlag(b)
  
  49
  >
  		})
  
  50
  
  }
  
  51

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/visibility.go 8 covered LOC · 1 range

Open complete file

  73
  
  )
  
  74
  
  75
  >
  func buildOnDuplicateKeyUpdate(fields ...string) string {
  
visibility.go

  76
  >
  	items := make([]string, len(fields))
  
  77
  >
  	for i, field := range fields {
  
  78
  >
  		// This line is to ensure that no update occurs (for any column) if the version is behind the saved version.
  
  79
  >
  		items[i] = fmt.Sprintf("%v = IF(%v < VALUES(%v), VALUES(%v), %v)",
  
  80
  >
  			field, sqlplugin.VersionColumnName, sqlplugin.VersionColumnName, field, field)
  
  81
  >
  	}
  
  82
  >
  	return fmt.Sprintf("ON DUPLICATE KEY UPDATE %s", strings.Join(items, ", "))
  
  83
  
  }
  
  84

go.temporal.io/server/common/tasks/priority.go 8 covered LOC · 2 ranges

Open complete file

  59
  
  )
  
  60
  
  61
  >
  func (p Priority) String() string {
  
priority.go

  62
  >
  	s, ok := PriorityName[p]
  
  63
  >
  	if ok {
  
  64
  >
  		return s
  
  65
  >
  	}
  
  66
  
  	return strconv.Itoa(int(p))
  
  67
  
  }

  77
  
  func getPriority(
  
  78
  
  	class, subClass Priority,
  
  79
  >
  ) Priority {
  
priority.go

  80
  >
  	return class | subClass
  
  81
  >
  }

go.temporal.io/server/service/history/queues/metrics.go 8 covered LOC · 4 ranges

Open complete file

  175
  
  func GetArchivalTaskTypeTagValue(
  
  176
  
  	task tasks.Task,
  
  177
  >
  ) string {
  
metrics.go

  178
  >
  	switch task.(type) {
  
  179
  >
  	case *tasks.ArchiveExecutionTask:
  
metrics.go

  180
  >
  		return metrics.TaskTypeArchivalTaskArchiveExecution
  
  181
  
  	default:
  
  182
  
  		return task.GetType().String()

  223
  
  	isActive bool,
  
  224
  
  	chasmRegistry *chasm.Registry,
  
  225
  >
  ) string {
  
metrics.go

  226
  >
  	switch task.GetCategory() {
  
  227
  
  	case tasks.CategoryTransfer:
  
  228
  
  		if isActive {

  237
  
  	case tasks.CategoryVisibility:
  
  238
  
  		return GetVisibilityTaskTypeTagValue(task)
  
  239
  >
  	case tasks.CategoryArchival:
  
metrics.go

  240
  >
  		return GetArchivalTaskTypeTagValue(task)
  
  241
  
  	case tasks.CategoryOutbound:
  
  242
  
  		return GetOutboundTaskTypeTagValue(task, isActive, chasmRegistry)

go.temporal.io/server/chasm/statemachine.go 7 covered LOC · 1 range

Open complete file

  34
  
  // The apply function is called after verifying the transition is possible but before setting the destination state,
  
  35
  
  // so it can inspect the current (source) state.
  
  36
  >
  func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, MutableContext, E) error) Transition[S, SM, E] {
  
statemachine.go

  37
  >
  	return Transition[S, SM, E]{
  
  38
  >
  		Sources:     src,
  
  39
  >
  		Destination: dst,
  
  40
  >
  		apply:       apply,
  
  41
  >
  	}
  
  42
  >
  }
  
  43
  
  44
  
  // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/common/dynamicconfig/registry.go 7 covered LOC · 3 ranges

Open complete file

  17
  
  )
  
  18
  
  19
  >
  func register(s GenericSetting) {
  
registry.go

  20
  >
  	if globalRegistry.queried.Load() {
  
  21
  
  		panic("dynamicconfig.New*Setting must only be called from static initializers")
  
  22
  
  	}
  
  23
  >
  	if globalRegistry.settings == nil {
  
registry.go

  24
  >
  		globalRegistry.settings = make(map[Key]GenericSetting)
  
  25
  >
  	}
  
  26
  >
  	if globalRegistry.settings[s.Key()] != nil {
  
  27
  
  		// nolint:forbidigo // only called during static initialization
  
  28
  
  		panic(fmt.Sprintf("duplicate registration of dynamic config key: %q", s.Key().String()))
  
  29
  
  	}
  
  30
  >
  	globalRegistry.settings[s.Key()] = s
  
registry.go

  31
  
  }
  
  32

go.temporal.io/server/common/log/noop_logger.go 7 covered LOC · 3 ranges

Open complete file

  10
  
  11
  
  // NewNoopLogger return a noopLogger
  
  12
  >
  func NewNoopLogger() *noopLogger {
  
noop_logger.go

  13
  >
  	return &noopLogger{}
  
  14
  >
  }
  
  15
  
  16
  >
  func (n *noopLogger) Debug(string, ...tag.Tag)  {}
  
noop_logger.go

  17
  
  func (n *noopLogger) Info(string, ...tag.Tag)   {}
  
  18
  
  func (n *noopLogger) Warn(string, ...tag.Tag)   {}

  21
  
  func (n *noopLogger) Panic(string, ...tag.Tag)  {}
  
  22
  
  func (n *noopLogger) Fatal(string, ...tag.Tag)  {}
  
  23
  >
  func (n *noopLogger) With(...tag.Tag) Logger {
  
noop_logger.go

  24
  >
  	return n
  
  25
  >
  }

go.temporal.io/server/common/membership/grpc_resolver.go 7 covered LOC · 2 ranges

Open complete file

  53
  
  )
  
  54
  
  55
  >
  func init() {
  
grpc_resolver.go

  56
  >
  	// This must be called in init to avoid race conditions.
  
  57
  >
  	resolver.Register(&globalGrpcBuilder)
  
  58
  >
  }
  
  59
  
  60
  
  // Most code should not use this, this is only exposed for code that has to recognize and use a

  80
  
  }
  
  81
  
  82
  >
  func (m *grpcBuilder) Scheme() string {
  
grpc_resolver.go

  83
  >
  	return grpcResolverScheme
  
  84
  >
  }
  
  85
  
  86
  
  func (m *grpcBuilder) getServiceResolver(u *url.URL) (ServiceResolver, error) {

go.temporal.io/server/service/history/hsm/sm.go 7 covered LOC · 1 range

Open complete file

  41
  
  // NewTransition creates a new [Transition] from the given source states to a destination state for a given event.
  
  42
  
  // The apply function is called after verifying the transition is possible and setting the destination state.
  
  43
  >
  func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, E) (TransitionOutput, error)) Transition[S, SM, E] {
  
sm.go

  44
  >
  	return Transition[S, SM, E]{
  
  45
  >
  		Sources:     src,
  
  46
  >
  		Destination: dst,
  
  47
  >
  		apply:       apply,
  
  48
  >
  	}
  
  49
  >
  }
  
  50
  
  51
  
  // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/service/history/workflow/task_generator_provider.go 7 covered LOC · 2 ranges

Open complete file

  23
  
  )
  
  24
  
  25
  >
  func init() {
  
task_generator_provider.go

  26
  >
  	var defaultProvider TaskGeneratorProvider = new(taskGeneratorProviderImpl)
  
  27
  >
  	populateTaskGeneratorProvider(defaultProvider)
  
  28
  >
  }
  
  29
  
  30
  >
  func populateTaskGeneratorProvider(provider TaskGeneratorProvider) {
  
task_generator_provider.go

  31
  >
  	_taskGeneratorProvider.Store(&provider)
  
  32
  >
  }
  
  33
  
  34
  
  func GetTaskGeneratorProvider() TaskGeneratorProvider {

go.temporal.io/server/common/clock/time_source.go 6 covered LOC · 2 ranges

Open complete file

  31
  
  32
  
  // NewRealTimeSource returns a timeSource that uses the real wall timeSource time.
  
  33
  >
  func NewRealTimeSource() RealTimeSource {
  
time_source.go

  34
  >
  	return RealTimeSource{}
  
  35
  >
  }
  
  36
  
  37
  
  // Now returns the current time, with the location set to UTC.
  
  38
  >
  func (ts RealTimeSource) Now() time.Time {
  
time_source.go

  39
  >
  	return time.Now().UTC()
  
  40
  >
  }
  
  41
  
  42
  
  // Since returns the time elapsed since t

go.temporal.io/server/common/log/lazy_logger.go 6 covered LOC · 1 range

Open complete file

  19
  
  )
  
  20
  
  21
  >
  func NewLazyLogger(logger Logger, tagFn func() []tag.Tag) *lazyLogger {
  
lazy_logger.go

  22
  >
  	return &lazyLogger{
  
  23
  >
  		logger: logger,
  
  24
  >
  		tagFn:  tagFn,
  
  25
  >
  	}
  
  26
  >
  }
  
  27
  
  28
  
  func (l *lazyLogger) Debug(msg string, tags ...tag.Tag) {

go.temporal.io/server/common/metrics/option.go 6 covered LOC · 2 ranges

Open complete file

  10
  
  type WithDescription string
  
  11
  
  12
  >
  func (h WithDescription) apply(m *metricDefinition) {
  
option.go

  13
  >
  	m.description = string(h)
  
  14
  >
  }
  
  15
  
  16
  
  // WithUnit sets the unit of a metric. See NewBytesHistogramDef for an example.
  
  17
  
  type WithUnit MetricUnit
  
  18
  
  19
  >
  func (h WithUnit) apply(m *metricDefinition) {
  
option.go

  20
  >
  	m.unit = MetricUnit(h)
  
  21
  >
  }

go.temporal.io/server/common/persistence/data_interfaces.go 6 covered LOC · 3 ranges

Open complete file

  1408
  
  // UnixMilliseconds returns t as a Unix time, the number of milliseconds elapsed since January 1, 1970 UTC.
  
  1409
  
  // It should be used for all CQL timestamp.
  
  1410
  >
  func UnixMilliseconds(t time.Time) int64 {
  
data_interfaces.go

  1411
  >
  	// Handling zero time separately because UnixNano is undefined for zero times.
  
  1412
  >
  	if t.IsZero() {
  
  1413
  
  		return 0
  
  1414
  
  	}
  
  1415
  
  1416
  >
  	unixNano := t.UnixNano()
  
data_interfaces.go

  1417
  >
  	if unixNano < 0 {
  
  1418
  
  		// Time is before January 1, 1970 UTC
  
  1419
  
  		return 0
  
  1420
  
  	}
  
  1421
  >
  	return unixNano / int64(time.Millisecond)
  
data_interfaces.go

  1422
  
  }
  
  1423

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/fixed_address_translator.go 6 covered LOC · 2 ranges

Open complete file

  15
  
  )
  
  16
  
  17
  >
  func init() {
  
fixed_address_translator.go

  18
  >
  	RegisterTranslator(fixedTranslatorName, NewFixedAddressTranslatorPlugin())
  
  19
  >
  }
  
  20
  
  21
  
  type FixedAddressTranslatorPlugin struct {
  
  22
  
  }
  
  23
  
  24
  >
  func NewFixedAddressTranslatorPlugin() TranslatorPlugin {
  
fixed_address_translator.go

  25
  >
  	return &FixedAddressTranslatorPlugin{}
  
  26
  >
  }
  
  27
  
  28
  
  // GetTranslator What gocql driver does is that it will connect to the first node in the list in configuration

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/plugin.go 6 covered LOC · 1 range

Open complete file

  43
  
  }
  
  44
  
  45
  >
  func init() {
  
plugin.go

  46
  >
  	sql.RegisterPlugin(PluginName, &plugin{
  
  47
  >
  		queryConverter: &queryConverter{},
  
  48
  >
  		connPool:       newConnPool(),
  
  49
  >
  	})
  
  50
  >
  }
  
  51
  
  52
  
  func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/service/history/configs/task.go 6 covered LOC · 1 range

Open complete file

  26
  
  func ConvertWeightsToDynamicConfigValue(
  
  27
  
  	weights map[tasks.Priority]int,
  
  28
  >
  ) map[string]any {
  
task.go

  29
  >
  	weightsForDC := make(map[string]any)
  
  30
  >
  	for priority, weight := range weights {
  
  31
  >
  		weightsForDC[priority.String()] = weight
  
  32
  >
  	}
  
  33
  >
  	return weightsForDC
  
  34
  
  }
  
  35

go.temporal.io/server/service/history/tasks/key.go 6 covered LOC · 1 range

Open complete file

  35
  
  }
  
  36
  
  37
  >
  func NewKey(fireTime time.Time, taskID int64) Key {
  
key.go

  38
  >
  	return Key{
  
  39
  >
  		FireTime: fireTime,
  
  40
  >
  		TaskID:   taskID,
  
  41
  >
  	}
  
  42
  >
  }
  
  43
  
  44
  
  func ValidateKey(key Key) error {

go.temporal.io/server/chasm/lib/nexusoperation/config.go 5 covered LOC · 1 range

Open complete file

  160
  
  }
  
  161
  
  162
  >
  func (cfg RetryPolicyConfig) build() backoff.RetryPolicy {
  
config.go

  163
  >
  	return backoff.NewExponentialRetryPolicy(cfg.InitialInterval).
  
  164
  >
  		WithMaximumInterval(cfg.MaxInterval).
  
  165
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  166
  >
  }
  
  167
  
  168
  
  var defaultRetryPolicyConfig = RetryPolicyConfig{

go.temporal.io/server/chasm/lib/scheduler/util.go 5 covered LOC · 1 range

Open complete file

  26
  
  27
  
  // serializeConflictToken serializes a conflict token as a byte slice.
  
  28
  >
  func serializeConflictToken(conflictToken int64) []byte {
  
util.go

  29
  >
  	token := make([]byte, 8)
  
  30
  >
  	binary.LittleEndian.PutUint64(token, uint64(conflictToken))
  
  31
  >
  	return token
  
  32
  >
  }
  
  33
  
  34
  
  // newTaggedLogger returns a logger tagged with the Scheduler's attributes.

go.temporal.io/server/chasm/nexus_operation_processor.go 5 covered LOC · 1 range

Open complete file

  165
  
  166
  
  // NewNexusEndpointProcessor creates a new NexusEndpointProcessor.
  
  167
  >
  func NewNexusEndpointProcessor() *NexusEndpointProcessor {
  
nexus_operation_processor.go

  168
  >
  	return &NexusEndpointProcessor{
  
  169
  >
  		serviceProcessors: make(map[string]*NexusServiceProcessor),
  
  170
  >
  	}
  
  171
  >
  }
  
  172
  
  173
  
  // RegisterServiceProcessor adds a service-level processor to the endpoint keyed by its name.

go.temporal.io/server/common/metrics/metrics_mock.go 5 covered LOC · 1 range

Open complete file

  31
  
  32
  
  // NewMockHandler creates a new mock instance.
  
  33
  >
  func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
  
metrics_mock.go

  34
  >
  	mock := &MockHandler{ctrl: ctrl}
  
  35
  >
  	mock.recorder = &MockHandlerMockRecorder{mock}
  
  36
  >
  	return mock
  
  37
  >
  }
  
  38
  
  39
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/metrics/registry.go 5 covered LOC · 1 range

Open complete file

  43
  
  44
  
  // register adds a metric definition to the list of pending metric definitions. This method is thread-safe.
  
  45
  >
  func (c *registry) register(d metricDefinition) {
  
registry.go

  46
  >
  	c.Lock()
  
  47
  >
  	defer c.Unlock()
  
  48
  >
  	c.definitions = append(c.definitions, d)
  
  49
  >
  }
  
  50
  
  51
  
  // buildCatalog builds a catalog from the list of pending metric definitions. It is safe to call this method multiple

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/plugin.go 5 covered LOC · 1 range

Open complete file

  24
  
  var _ sqlplugin.Plugin = (*plugin)(nil)
  
  25
  
  26
  >
  func init() {
  
plugin.go

  27
  >
  	sql.RegisterPlugin(PluginName, &plugin{
  
  28
  >
  		queryConverter: &queryConverter{},
  
  29
  >
  	})
  
  30
  >
  }
  
  31
  
  32
  
  func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/conn_pool.go 5 covered LOC · 1 range

Open complete file

  23
  
  }
  
  24
  
  25
  >
  func newConnPool() *connPool {
  
conn_pool.go

  26
  >
  	return &connPool{
  
  27
  >
  		pool: make(map[string]entry),
  
  28
  >
  	}
  
  29
  >
  }
  
  30
  
  31
  
  // Allocate allocates the shared database in the pool or returns already exists instance with the same DSN. If instance

go.temporal.io/server/common/persistence/visibility/manager/visibility_manager_mock.go 5 covered LOC · 1 range

Open complete file

  32
  
  33
  
  // NewMockVisibilityManager creates a new mock instance.
  
  34
  >
  func NewMockVisibilityManager(ctrl *gomock.Controller) *MockVisibilityManager {
  
visibility_manager_mock.go

  35
  >
  	mock := &MockVisibilityManager{ctrl: ctrl}
  
  36
  >
  	mock.recorder = &MockVisibilityManagerMockRecorder{mock}
  
  37
  >
  	return mock
  
  38
  >
  }
  
  39
  
  40
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/archiver/uri.go 4 covered LOC · 2 ranges

Open complete file

  25
  
  26
  
  // NewURI constructs a new archiver URI from string.
  
  27
  >
  func NewURI(s string) (URI, error) {
  
uri.go

  28
  >
  	url, err := url.ParseRequestURI(s)
  
  29
  >
  	if err != nil {
  
  30
  
  		return nil, err
  
  31
  
  	}
  
  32
  >
  	return &uri{url: url}, nil
  
uri.go

  33
  
  }
  
  34

go.temporal.io/server/common/log/with_logger.go 4 covered LOC · 2 ranges

Open complete file

  14
  
  // With returns Logger instance that prepend every log entry with tags. If logger implements
  
  15
  
  // WithLogger it is used, otherwise every log call will be intercepted.
  
  16
  >
  func With(logger Logger, tags ...tag.Tag) Logger {
  
with_logger.go

  17
  >
  	if wl, ok := logger.(WithLogger); ok {
  
  18
  >
  		return wl.With(tags...)
  
with_logger.go

  19
  >
  	}
  
  20
  
  	return newWithLogger(logger, tags...)
  
  21
  
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/typeconv.go 4 covered LOC · 2 ranges

Open complete file

  33
  
  }
  
  34
  
  35
  >
  func getMinMySQLDateTime() time.Time {
  
typeconv.go

  36
  >
  	t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")
  
  37
  >
  	if err != nil {
  
  38
  
  		return time.Unix(0, 0).UTC()
  
  39
  
  	}
  
  40
  >
  	return t.UTC()
  
typeconv.go

  41
  
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/typeconv.go 4 covered LOC · 2 ranges

Open complete file

  35
  
  }
  
  36
  
  37
  >
  func getMinPostgreSQLDateTime() time.Time {
  
typeconv.go

  38
  >
  	t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")
  
  39
  >
  	if err != nil {
  
  40
  
  		return time.Unix(0, 0).UTC()
  
  41
  
  	}
  
  42
  >
  	return t.UTC()
  
typeconv.go

  43
  
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/typeconv.go 4 covered LOC · 2 ranges

Open complete file

  33
  
  }
  
  34
  
  35
  >
  func getMinSQLiteDateTime() time.Time {
  
typeconv.go

  36
  >
  	t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")
  
  37
  >
  	if err != nil {
  
  38
  
  		return time.Unix(0, 0).UTC()
  
  39
  
  	}
  
  40
  >
  	return t.UTC()
  
typeconv.go

  41
  
  }

go.temporal.io/server/common/telemetry/config.go 4 covered LOC · 1 range

Open complete file

  417
  
  }
  
  418
  
  419
  >
  func IsEnabled(t trace.Tracer) bool {
  
config.go

  420
  >
  	_, isNoop := t.(otelnoop.Tracer)
  
  421
  >
  	return !isNoop
  
  422
  >
  }

go.temporal.io/server/api/persistence/v1/predicates.go-helpers.pb.go 3 covered LOC · 1 range

Open complete file

  17
  
  18
  
  // Size returns the size of the object, in bytes, once serialized
  
  19
  >
  func (val *Predicate) Size() int {
  
predicates.go-helpers.pb.go

  20
  >
  	return proto.Size(val)
  
  21
  >
  }
  
  22
  
  23
  
  // Equal returns whether two Predicate values are equivalent by recursively

go.temporal.io/server/chasm/library.go 3 covered LOC · 1 range

Open complete file

  56
  
  // tasks within the CHASM framework.
  
  57
  
  // The format of the returned FQN is: "libName.name"
  
  58
  >
  func FullyQualifiedName(libName, name string) string {
  
library.go

  59
  >
  	return libName + "." + name
  
  60
  >
  }

go.temporal.io/server/chasm/registrable_component.go 3 covered LOC · 1 range

Open complete file

  203
  
  // The generated ID is used to uniquely identify components and tasks within the CHASM framework. The same FQN will
  
  204
  
  // always produce the same ID.
  
  205
  >
  func GenerateTypeID(fqn string) uint32 {
  
registrable_component.go

  206
  >
  	return farm.Fingerprint32([]byte(fqn))
  
  207
  >
  }
  
  208
  
  209
  
  // hasBusinessIDAlias returns true if the component has a businessID alias configured

go.temporal.io/server/common/backoff/jitter.go 3 covered LOC · 1 range

Open complete file

  4
  
  5
  
  // FullJitter return random number from 0 to input, inclusive, exclusive
  
  6
  >
  func FullJitter[T ~int64 | ~int | ~int32 | ~float64 | ~float32](input T) T {
  
jitter.go

  7
  >
  	return T(rand.Float64() * float64(input))
  
  8
  >
  }
  
  9
  
  10
  
  // Jitter return random number from (1-coefficient)*input to (1+coefficient)*input, inclusive, exclusive

go.temporal.io/server/common/dynamicconfig/key.go 3 covered LOC · 1 range

Open complete file

  13
  
  )
  
  14
  
  15
  >
  func MakeKey(s string) Key {
  
key.go

  16
  >
  	return Key{handle: unique.Make(strings.ToLower(s))}
  
  17
  >
  }
  
  18
  
  19
  
  func (k Key) String() string {

go.temporal.io/server/common/membership/hostinfo.go 3 covered LOC · 1 range

Open complete file

  12
  
  13
  
  // NewHostInfoFromAddress creates a new HostInfo instance from a socket address.
  
  14
  >
  func NewHostInfoFromAddress(address string) HostInfo {
  
hostinfo.go

  15
  >
  	return hostAddress(address)
  
  16
  >
  }
  
  17
  
  18
  
  // hostAddress is a HostInfo implementation that uses a string as the address and identity.

go.temporal.io/server/common/payload/payload.go 3 covered LOC · 1 range

Open complete file

  30
  
  }
  
  31
  
  32
  >
  func Encode(value any) (*commonpb.Payload, error) {
  
payload.go

  33
  >
  	return defaultDataConverter.ToPayload(value)
  
  34
  >
  }
  
  35
  
  36
  
  func Decode(p *commonpb.Payload, valuePtr any) error {

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/translator_plugin.go 3 covered LOC · 1 range

Open complete file

  22
  
  // RegisterPlugin adds an auth plugin to the plugin registry
  
  23
  
  // it is only safe to use from a package init function
  
  24
  >
  func RegisterTranslator(name string, plugin TranslatorPlugin) {
  
translator_plugin.go

  25
  >
  	translators[name] = plugin
  
  26
  >
  }
  
  27
  
  28
  
  func LookupTranslator(name string) (TranslatorPlugin, error) {

go.temporal.io/server/common/persistence/persistence_rate_limited_clients.go 3 covered LOC · 1 range

Open complete file

  1182
  
  	baseAPI string,
  
  1183
  
  	taskCategory tasks.Category,
  
  1184
  >
  ) string {
  
persistence_rate_limited_clients.go

  1185
  >
  	return baseAPI + taskCategory.Name()
  
  1186
  >
  }

go.temporal.io/server/common/persistence/sql/store.go 3 covered LOC · 2 ranges

Open complete file

  19
  
  20
  
  // RegisterPlugin will register a SQL plugin
  
  21
  >
  func RegisterPlugin(pluginName string, plugin sqlplugin.Plugin) {
  
store.go

  22
  >
  	if _, ok := supportedPlugins[pluginName]; ok {
  
  23
  
  		panic("plugin " + pluginName + " already registered")
  
  24
  
  	}
  
  25
  >
  	supportedPlugins[pluginName] = plugin
  
store.go

  26
  
  }
  
  27

go.temporal.io/server/service/history/queues/errors/errors.go 3 covered LOC · 1 range

Open complete file

  39
  
  40
  
  // NewUnprocessableTaskError returns a new UnprocessableTaskError from given message.
  
  41
  >
  func NewUnprocessableTaskError(message string) *UnprocessableTaskError {
  
errors.go

  42
  >
  	return &UnprocessableTaskError{Message: message}
  
  43
  >
  }
  
  44
  
  45
  
  func (e UnprocessableTaskError) Error() string {

go.temporal.io/server/service/history/tasks/category.go 3 covered LOC · 1 range

Open complete file

  100
  
  }
  
  101
  
  102
  >
  func (c Category) Name() string {
  
category.go

  103
  >
  	return c.name
  
  104
  >
  }
  
  105
  
  106
  
  func (c Category) Type() CategoryType {

go.temporal.io/server/service/history/workflow/noop_chasm_tree.go 3 covered LOC · 1 range

Open complete file

  62
  
  }
  
  63
  
  64
  >
  func (*noopChasmTree) ArchetypeID() chasm.ArchetypeID {
  
noop_chasm_tree.go

  65
  >
  	return chasm.WorkflowArchetypeID
  
  66
  >
  }
  
  67
  
  68
  
  func (*noopChasmTree) EachPureTask(

go.temporal.io/server/common/metrics/metrics.go 2 covered LOC · 2 ranges

Open complete file

  80
  
  )
  
  81
  
  82
  >
  func (c CounterFunc) Record(v int64, tags ...Tag)       { c(v, tags...) }
  
metrics.go

  83
  
  func (c GaugeFunc) Record(v float64, tags ...Tag)       { c(v, tags...) }
  
  84
  >
  func (c TimerFunc) Record(v time.Duration, tags ...Tag) { c(v, tags...) }
  
metrics.go

  85
  
  func (c HistogramFunc) Record(v int64, tags ...Tag)     { c(v, tags...) }

go.temporal.io/server/common/persistence/client/fx.go 2 covered LOC · 1 range

Open complete file

  224
  
  }
  
  225
  
  226
  >
  func managerProvider[T persistence.Closeable](newManagerFn func(Factory) (T, error)) func(Factory, fx.Lifecycle) (T, error) {
  
fx.go

  227
  >
  	return func(f Factory, lc fx.Lifecycle) (T, error) {
  
  228
  
  		manager, err := newManagerFn(f) // passing receiver (Factory) as first argument.
  
  229
  
  		if err != nil {

go.temporal.io/server/common/aggregate/noop_moving_window_average.go 1 covered LOC · 1 range

Open complete file

  7
  
  )
  
  8
  
  9
  >
  func newNoopMovingWindowAverage() *noopMovingWindowAverage { return &noopMovingWindowAverage{} }
  
noop_moving_window_average.go

  10
  
  11
  
  func (a *noopMovingWindowAverage) Record(_ int64) {}

go.temporal.io/server/common/persistence/noop_health_signal_aggregator.go 1 covered LOC · 1 range

Open complete file

  11
  
  )
  
  12
  
  13
  >
  func newNoopSignalAggregator() *noopSignalAggregator { return &noopSignalAggregator{} }
  
noop_health_signal_aggregator.go

  14
  
  15
  
  func (a *noopSignalAggregator) Start() {}

Covered source