chore: Support taskExecutionIds

taskExecutionId is a new field, the values is unique among retries of the activity

Signed-off-by: Javier Aliaga <[email protected]>

Author: javier-aliaga

api/protos/orchestrator_service.pb.go

@@ -2,14 +2,16 @@ package backend
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
 	"github.com/dapr/durabletask-go/api"
 	"github.com/dapr/durabletask-go/api/protos"
 	"github.com/dapr/durabletask-go/backend/runtimestate"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 var (
@@ -137,6 +139,15 @@ func MarshalHistoryEvent(e *HistoryEvent) ([]byte, error) {
 	}
 }
 
+// MarshalJsonHistoryEvent serializes the [HistoryEvent] into a protobuf byte array.
+func MarshalJsonHistoryEvent(e *HistoryEvent) ([]byte, error) {
+	if bytes, err := json.Marshal(e); err != nil {
+		return nil, fmt.Errorf("failed to marshal history event: %w", err)
+	} else {
+		return bytes, nil
+	}
+}
+
 // UnmarshalHistoryEvent deserializes a [HistoryEvent] from a protobuf byte array.
 func UnmarshalHistoryEvent(bytes []byte) (*HistoryEvent, error) {
 	e := &protos.HistoryEvent{}

api/protos/orchestrator_service_grpc.pb.go

@@ -1,7 +1,7 @@
 package backend
 
 import (
-	context "context"
+	"context"
 	"errors"
 	"fmt"
 	"strconv"
@@ -172,6 +172,7 @@ func (executor *grpcExecutor) ExecuteActivity(ctx context.Context, iid api.Insta
 				Input:                 task.Input,
 				OrchestrationInstance: &protos.OrchestrationInstance{InstanceId: string(iid)},
 				TaskId:                e.EventId,
+				TaskExecutionId:       task.TaskExecutionId,
 			},
 		},
 	}

backend/backend.go

@@ -5,12 +5,13 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/dapr/durabletask-go/api"
-	"github.com/dapr/durabletask-go/api/helpers"
-	"github.com/dapr/durabletask-go/api/protos"
 	"github.com/google/uuid"
 	"google.golang.org/protobuf/types/known/timestamppb"
 	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/dapr/durabletask-go/api"
+	"github.com/dapr/durabletask-go/api/helpers"
+	"github.com/dapr/durabletask-go/api/protos"
 )
 
 var ErrDuplicateEvent = errors.New("duplicate event")
@@ -188,6 +189,7 @@ func ApplyActions(s *protos.OrchestrationRuntimeState, customStatus *wrapperspb.
 				EventType: &protos.HistoryEvent_TaskScheduled{
 					TaskScheduled: &protos.TaskScheduledEvent{
 						Name:               scheduleTask.Name,
+						TaskExecutionId:    scheduleTask.TaskExecutionId,
 						Version:            scheduleTask.Version,
 						Input:              scheduleTask.Input,
 						ParentTraceContext: currentTraceContext,

backend/executor.go

@@ -8,15 +8,16 @@ import (
 	"time"
 
 	"github.com/cenkalti/backoff/v4"
-	"github.com/dapr/durabletask-go/api"
-	"github.com/dapr/durabletask-go/api/protos"
-	"github.com/dapr/durabletask-go/backend"
-	"github.com/dapr/durabletask-go/task"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/dapr/durabletask-go/api"
+	"github.com/dapr/durabletask-go/api/protos"
+	"github.com/dapr/durabletask-go/backend"
+	"github.com/dapr/durabletask-go/task"
 )
 
 type workItemsStream interface {
@@ -183,6 +184,7 @@ func (c *TaskHubGrpcClient) processActivityWorkItem(
 				Name:               req.Name,
 				Version:            req.Version,
 				Input:              req.Input,
+				TaskExecutionId:    req.TaskExecutionId,
 				ParentTraceContext: tc,
 			},
 		},

backend/runtimestate/runtimestate.go

@@ -4,8 +4,9 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"log"
-	"math/rand"
+	"sync"
 	"time"
 
 	"github.com/dapr/durabletask-go/backend"
@@ -16,16 +17,18 @@ import (
 func main() {
 	// Create a new task registry and add the orchestrator and activities
 	r := task.NewTaskRegistry()
-	r.AddOrchestrator(RetryActivityOrchestrator)
-	r.AddActivity(RandomFailActivity)
+	must(r.AddOrchestrator(RetryActivityOrchestrator))
+	must(r.AddActivity(RandomFailActivity))
 
 	// Init the client
 	ctx := context.Background()
 	client, worker, err := Init(ctx, r)
 	if err != nil {
 		log.Fatalf("Failed to initialize the client: %v", err)
 	}
-	defer worker.Shutdown(ctx)
+	defer func() {
+		must(worker.Shutdown(ctx))
+	}()
 
 	// Start a new orchestration
 	id, err := client.ScheduleNewOrchestration(ctx, RetryActivityOrchestrator)
@@ -56,7 +59,7 @@ func Init(ctx context.Context, r *task.TaskRegistry) (backend.TaskHubClient, bac
 
 	// Create a new backend
 	// Use the in-memory sqlite provider by specifying ""
-	be := sqlite.NewSqliteBackend(sqlite.NewSqliteOptions(""), logger)
+	be := sqlite.NewSqliteBackend(sqlite.NewSqliteOptions("/Users/javi/projects/javi-durabletask-go/backend/sqlite/retries"), logger)
 	orchestrationWorker := backend.NewOrchestrationWorker(be, executor, logger)
 	activityWorker := backend.NewActivityTaskWorker(be, executor, logger)
 	taskHubWorker := backend.NewTaskHubWorker(be, orchestrationWorker, activityWorker, logger)
@@ -74,22 +77,89 @@ func Init(ctx context.Context, r *task.TaskRegistry) (backend.TaskHubClient, bac
 }
 
 func RetryActivityOrchestrator(ctx *task.OrchestrationContext) (any, error) {
-	if err := ctx.CallActivity(RandomFailActivity, task.WithActivityRetryPolicy(&task.RetryPolicy{
+	t := ctx.CallActivity(RandomFailActivity, task.WithActivityRetryPolicy(&task.RetryPolicy{
 		MaxAttempts:          10,
 		InitialRetryInterval: 100 * time.Millisecond,
 		BackoffCoefficient:   2,
 		MaxRetryInterval:     3 * time.Second,
-	})).Await(nil); err != nil {
+	}))
+
+	t1 := ctx.CallActivity(RandomFailActivity, task.WithActivityRetryPolicy(&task.RetryPolicy{
+		MaxAttempts:          10,
+		InitialRetryInterval: 100 * time.Millisecond,
+		BackoffCoefficient:   2,
+		MaxRetryInterval:     3 * time.Second,
+	}))
+
+	if err := t.Await(nil); err != nil {
 		return nil, err
 	}
+
+	if err := t1.Await(nil); err != nil {
+		return nil, err
+	}
+
 	return nil, nil
 }
 
+type Counter struct {
+	c    int32
+	lock sync.Mutex
+}
+
+func (c *Counter) Increment() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	c.c++
+}
+
+func (c *Counter) GetValue() int32 {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.c
+}
+
+var (
+	counters     = make(map[string]*Counter)
+	countersLock sync.RWMutex
+)
+
+// GetCounter returns a Counter instance for the specified taskExecutionId.
+// If no counter exists for the taskExecutionId, a new one is created.
+func GetCounter(taskExecutionId string) *Counter {
+	countersLock.RLock()
+	counter, exists := counters[taskExecutionId]
+	countersLock.RUnlock()
+
+	if !exists {
+		countersLock.Lock()
+		// Check again to handle race conditions
+		counter, exists = counters[taskExecutionId]
+		if !exists {
+			counter = &Counter{}
+			counters[taskExecutionId] = counter
+		}
+		countersLock.Unlock()
+	}
+
+	return counter
+}
+
 func RandomFailActivity(ctx task.ActivityContext) (any, error) {
+	log.Println(fmt.Sprintf("#### [%v] activity %v failure", ctx.GetTaskExecutionId(), ctx.GetTaskID()))
+
 	// 70% possibility for activity failure
-	if rand.Intn(100) <= 70 {
+	if GetCounter(ctx.GetTaskExecutionId()).GetValue() != 5 {
 		log.Println("random activity failure")
+		GetCounter(ctx.GetTaskExecutionId()).Increment()
 		return "", errors.New("random activity failure")
 	}
+
 	return "ok", nil
 }
+
+func must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

client/worker_grpc.go

@@ -6,15 +6,17 @@ import (
 	"math"
 	"time"
 
-	"github.com/dapr/durabletask-go/api/protos"
 	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/dapr/durabletask-go/api/protos"
 )
 
 type callActivityOption func(*callActivityOptions) error
 
 type callActivityOptions struct {
-	rawInput    *wrapperspb.StringValue
-	retryPolicy *RetryPolicy
+	rawInput        *wrapperspb.StringValue
+	retryPolicy     *RetryPolicy
+	taskExecutionId string
 }
 
 type RetryPolicy struct {
@@ -95,12 +97,15 @@ func WithActivityRetryPolicy(policy *RetryPolicy) callActivityOption {
 // ActivityContext is the context parameter type for activity implementations.
 type ActivityContext interface {
 	GetInput(resultPtr any) error
+	GetTaskID() int32
+	GetTaskExecutionId() string
 	Context() context.Context
 }
 
 type activityContext struct {
-	TaskID int32
-	Name   string
+	TaskID          int32
+	TaskExecutionId string
+	Name            string
 
 	rawInput []byte
 	ctx      context.Context
@@ -111,10 +116,11 @@ type Activity func(ctx ActivityContext) (any, error)
 
 func newTaskActivityContext(ctx context.Context, taskID int32, ts *protos.TaskScheduledEvent) *activityContext {
 	return &activityContext{
-		TaskID:   taskID,
-		Name:     ts.Name,
-		rawInput: []byte(ts.Input.GetValue()),
-		ctx:      ctx,
+		TaskID:          taskID,
+		TaskExecutionId: ts.TaskExecutionId,
+		Name:            ts.Name,
+		rawInput:        []byte(ts.Input.GetValue()),
+		ctx:             ctx,
 	}
 }
 
@@ -126,3 +132,11 @@ func (actx *activityContext) GetInput(v any) error {
 func (actx *activityContext) Context() context.Context {
 	return actx.ctx
 }
+
+func (actx *activityContext) GetTaskID() int32 {
+	return actx.TaskID
+}
+
+func (actx *activityContext) GetTaskExecutionId() string {
+	return actx.TaskExecutionId
+}

samples/retries/retries.go

@@ -6,11 +6,12 @@ import (
 	"fmt"
 	"time"
 
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
 	"github.com/dapr/durabletask-go/api"
 	"github.com/dapr/durabletask-go/api/protos"
 	"github.com/dapr/durabletask-go/backend"
-	"google.golang.org/protobuf/types/known/timestamppb"
-	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
 type taskExecutor struct {
@@ -42,6 +43,7 @@ func (te *taskExecutor) ExecuteActivity(ctx context.Context, id api.InstanceID,
 				EventType: &protos.HistoryEvent_TaskFailed{
 					TaskFailed: &protos.TaskFailedEvent{
 						TaskScheduledId: e.EventId,
+						TaskExecutionId: ts.GetTaskExecutionId(),
 						FailureDetails: &protos.TaskFailureDetails{
 							ErrorType:    "TaskActivityNotRegistered",
 							ErrorMessage: fmt.Sprintf("no task activity named '%s' was registered", ts.Name),
@@ -81,6 +83,7 @@ func (te *taskExecutor) ExecuteActivity(ctx context.Context, id api.InstanceID,
 			EventType: &protos.HistoryEvent_TaskFailed{
 				TaskFailed: &protos.TaskFailedEvent{
 					TaskScheduledId: e.EventId,
+					TaskExecutionId: ts.GetTaskExecutionId(),
 					FailureDetails: &protos.TaskFailureDetails{
 						ErrorType:    fmt.Sprintf("%T", err),
 						ErrorMessage: fmt.Sprintf("%+v", err),
@@ -98,6 +101,7 @@ func (te *taskExecutor) ExecuteActivity(ctx context.Context, id api.InstanceID,
 			EventType: &protos.HistoryEvent_TaskFailed{
 				TaskFailed: &protos.TaskFailedEvent{
 					TaskScheduledId: e.EventId,
+					TaskExecutionId: ts.GetTaskExecutionId(),
 					FailureDetails: &protos.TaskFailureDetails{
 						ErrorType:    fmt.Sprintf("%T", err),
 						ErrorMessage: fmt.Sprintf("%+v", err),
@@ -116,6 +120,7 @@ func (te *taskExecutor) ExecuteActivity(ctx context.Context, id api.InstanceID,
 		EventType: &protos.HistoryEvent_TaskCompleted{
 			TaskCompleted: &protos.TaskCompletedEvent{
 				TaskScheduledId: e.EventId,
+				TaskExecutionId: ts.GetTaskExecutionId(),
 				Result:          rawResult,
 			},
 		},