Introduce EnableStrictNonDeterminismCheck worker option

Author: taylanisikdemir

internal/internal_task_handlers.go

@@ -131,6 +131,7 @@ type (
 		contextPropagators             []ContextPropagator
 		tracer                         opentracing.Tracer
 		workflowInterceptorFactories   []WorkflowInterceptorFactory
+		enableStrictNonDeterminism     bool
 	}
 
 	activityProvider func(name string) activity
@@ -388,7 +389,7 @@ func newWorkflowTaskHandler(
 	registry *registry,
 ) WorkflowTaskHandler {
 	ensureRequiredParams(&params)
-	return &workflowTaskHandlerImpl{
+	wth := &workflowTaskHandlerImpl{
 		domain:                         domain,
 		logger:                         params.Logger,
 		ppMgr:                          ppMgr,
@@ -402,7 +403,16 @@ func newWorkflowTaskHandler(
 		contextPropagators:             params.ContextPropagators,
 		tracer:                         params.Tracer,
 		workflowInterceptorFactories:   params.WorkflowInterceptorChainFactories,
+		enableStrictNonDeterminism:     params.WorkerBugPorts.EnableStrictNonDeterminismCheck,
 	}
+
+	traceLog(func() {
+		wth.logger.Debug("Workflow task handler is created.",
+			zap.String(tagDomain, wth.domain),
+			zap.Bool("EnableStrictNonDeterminism", wth.enableStrictNonDeterminism))
+	})
+
+	return wth
 }
 
 // TODO: need a better eviction policy based on memory usage

internal/internal_worker.go

@@ -1041,7 +1041,7 @@ func newAggregatedWorker(
 	var workflowWorker *workflowWorker
 	if !wOptions.DisableWorkflowWorker {
 		testTags := getTestTags(wOptions.BackgroundActivityContext)
-		if testTags != nil && len(testTags) > 0 {
+		if len(testTags) > 0 {
 			workflowWorker = newWorkflowWorkerWithPressurePoints(
 				service,
 				domain,

internal/internal_worker_test.go

@@ -227,6 +227,14 @@ func (s *internalWorkerTestSuite) TestCreateWorker_WithAutoScaler() {
 	worker.Stop()
 }
 
+func (s *internalWorkerTestSuite) TestCreateWorker_WithStrictNonDeterminism() {
+	worker := createWorkerWithStrictNonDeterminismOption(s.T(), s.service)
+	err := worker.Start()
+	require.NoError(s.T(), err)
+	time.Sleep(time.Millisecond * 200)
+	worker.Stop()
+}
+
 func (s *internalWorkerTestSuite) TestCreateWorker_WithHost() {
 	worker := createWorkerWithHost(s.T(), s.service)
 	err := worker.Start()
@@ -425,6 +433,13 @@ func createWorkerWithAutoscaler(
 	return createWorkerWithThrottle(t, service, float64(0), WorkerOptions{FeatureFlags: FeatureFlags{PollerAutoScalerEnabled: true}})
 }
 
+func createWorkerWithStrictNonDeterminismOption(
+	t *testing.T,
+	service *workflowservicetest.MockClient,
+) *aggregatedWorker {
+	return createWorkerWithThrottle(t, service, float64(0), WorkerOptions{WorkerBugPorts: WorkerBugPorts{EnableStrictNonDeterminismCheck: true}})
+}
+
 func createWorkerWithHost(
 	t *testing.T,
 	service *workflowservicetest.MockClient,

internal/worker.go

@@ -266,6 +266,27 @@ type (
 		// Optional: Host is just string on the machine running the client
 		// default: empty string
 		Host string
+
+		// Optional: See WorkerBugPorts for more details
+		WorkerBugPorts WorkerBugPorts
+	}
+
+	// WorkerBugPorts allows opt-in enabling of older, possibly buggy behavior, primarily intended to allow temporarily
+	// emulating old behavior until a fix is deployed.
+	// By default, bugs (especially rarely-occurring ones) are fixed and all users are opted into the new behavior.
+	// Back-ported buggy behavior *may* be available via these flags.
+	//
+	// Bugports are always deprecated and may be removed in future versions.
+	// Generally speaking they will *likely* remain in place for one minor version, and then they may be removed to
+	// allow cleaning up the additional code complexity that they cause.
+	WorkerBugPorts struct {
+		// Optional: Enable strict non-determinism checks for workflow.
+		// There are some non-determinism cases which are missed by original implementation and a fix is on the way.
+		// The fix will be activated by this option which basicakky accuracy of the non-determinism checks.
+		// Exposing this as bugport for now to avoid breaking existing workflows which are actually non-deterministic but users depend on this.
+		// Once we identify such cases and notify users, we can enable this by default.
+		// default: false
+		EnableStrictNonDeterminismCheck bool
 	}
 )