remove Gob encoder

Author: maxdml

dbos/client.go

@@ -239,22 +239,7 @@ func Enqueue[P any, R any](c Client, queueName, workflowName string, input P, op
 	if c == nil {
 		return nil, errors.New("client cannot be nil")
 	}
-
-	// Register the input and outputs for gob encoding
-	var logger *slog.Logger
-	var serializer Serializer
-	if cl, ok := c.(*client); ok {
-		if ctx, ok := cl.dbosCtx.(*dbosContext); ok {
-			logger = ctx.logger
-			serializer = ctx.serializer
-		}
-	}
-	var typedInput P
-	var typedOutput R
-	if isGobSerializer(serializer) {
-		safeGobRegister(typedInput, logger)
-		safeGobRegister(typedOutput, logger)
-	}
+    
 
 	// Call the interface method with the same signature
 	handle, err := c.Enqueue(queueName, workflowName, input, opts...)

dbos/dbos.go

@@ -78,7 +78,7 @@ func processConfig(inputConfig *Config) (*Config, error) {
 		dbosConfig.DatabaseSchema = _DEFAULT_SYSTEM_DB_SCHEMA
 	}
 	if dbosConfig.Serializer == nil {
-		dbosConfig.Serializer = NewGobSerializer()
+		dbosConfig.Serializer = NewJSONSerializer()
 	}
 
 	// Override with environment variables if set
@@ -370,15 +370,7 @@ func NewDBOSContext(ctx context.Context, inputConfig Config) (DBOSContext, error
 	initExecutor.executorID = config.ExecutorID
 	initExecutor.serializer = config.Serializer
 
-	// Register types we serialize with gob (only if using GobSerializer)
-	if isGobSerializer(initExecutor.serializer) {
-		var t time.Time
-		safeGobRegister(t, initExecutor.logger)
-		var ws []WorkflowStatus
-		safeGobRegister(ws, initExecutor.logger)
-		var si []StepInfo
-		safeGobRegister(si, initExecutor.logger)
-	}
+
 
 	initExecutor.applicationID = os.Getenv("DBOS__APPID")
 

dbos/serialization.go

@@ -1,14 +1,10 @@
 package dbos
 
 import (
-	"bytes"
 	"encoding/base64"
-	"encoding/gob"
 	"encoding/json"
 	"fmt"
-	"log/slog"
 	"reflect"
-	"strings"
 )
 
 // Serializer defines the interface for pluggable serializers.
@@ -20,53 +16,6 @@ type Serializer interface {
 	Decode(data *string) (any, error)
 }
 
-// GobSerializer implements Serializer using encoding/gob
-type GobSerializer struct{}
-
-func NewGobSerializer() *GobSerializer {
-	return &GobSerializer{}
-}
-
-// Encode serializes data using gob and encodes it to a base64 string
-// Performs "lazy" registration of the type with gob
-func (g *GobSerializer) Encode(data any) (string, error) {
-	var inputBytes []byte
-	if !isNilValue(data) {
-		// Register the type with gob for proper serialization
-		// This is useful when dealing with interface types that didn't have a concrete value at workflow registration time
-		safeGobRegister(data, nil)
-
-		var buf bytes.Buffer
-		enc := gob.NewEncoder(&buf)
-		if err := enc.Encode(&data); err != nil {
-			return "", fmt.Errorf("failed to encode data: %w", err)
-		}
-		inputBytes = buf.Bytes()
-	}
-	return base64.StdEncoding.EncodeToString(inputBytes), nil
-}
-
-// Decode deserializes data from a base64 string using gob
-func (g *GobSerializer) Decode(data *string) (any, error) {
-	if data == nil || *data == "" {
-		return nil, nil
-	}
-
-	dataBytes, err := base64.StdEncoding.DecodeString(*data)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode data: %w", err)
-	}
-
-	var result any
-	buf := bytes.NewBuffer(dataBytes)
-	dec := gob.NewDecoder(buf)
-	if err := dec.Decode(&result); err != nil {
-		return nil, fmt.Errorf("failed to decode data: %w", err)
-	}
-
-	return result, nil
-}
-
 // JSONSerializer implements Serializer using encoding/json
 type JSONSerializer struct{}
 
@@ -123,12 +72,6 @@ func isJSONSerializer(s Serializer) bool {
 	return ok
 }
 
-// isGobSerializer checks if the given serializer is a GobSerializer
-func isGobSerializer(s Serializer) bool {
-	_, ok := s.(*GobSerializer)
-	return ok
-}
-
 // convertJSONToType converts a JSON-decoded value (map[string]interface{}) to type T
 // via marshal/unmarshal round-trip.
 //
@@ -145,8 +88,6 @@ func convertJSONToType[T any](value any) (T, error) {
 		return *new(T), fmt.Errorf("marshaling for type conversion: %w", err)
 	}
 
-	fmt.Println("convertJSONToType:", string(jsonBytes))
-
 	// Check if T is an interface type
 	var zero T
 	typeOfT := reflect.TypeOf(&zero).Elem()
@@ -194,28 +135,3 @@ func isNilValue(data any) bool {
 	}
 	return false
 }
-
-// safeGobRegister attempts to register a type with gob, recovering only from
-// panics caused by duplicate type/name registrations (e.g., registering both T and *T).
-// These specific conflicts don't affect encoding/decoding correctness, so they're safe to ignore.
-// Other panics (like register `any`) are real errors and will propagate.
-func safeGobRegister(value any, logger *slog.Logger) {
-	defer func() {
-		if r := recover(); r != nil {
-			if errStr, ok := r.(string); ok {
-				// Check if this is one of the two specific duplicate registration errors we want to ignore
-				// See https://cs.opensource.google/go/go/+/refs/tags/go1.25.1:src/encoding/gob/type.go;l=832
-				if strings.Contains(errStr, "gob: registering duplicate types for") ||
-					strings.Contains(errStr, "gob: registering duplicate names for") {
-					if logger != nil {
-						logger.Debug("gob registration conflict", "type", fmt.Sprintf("%T", value), "error", r)
-					}
-					return
-				}
-			}
-			// Re-panic for any other errors
-			panic(r)
-		}
-	}()
-	gob.Register(value)
-}

dbos/serialization_test.go

@@ -553,7 +553,6 @@ func serializerAnyRecoveryWorkflow(ctx DBOSContext, input any) (any, error) {
 func TestSerializer(t *testing.T) {
 	serializers := map[string]func() Serializer{
 		"JSON": func() Serializer { return NewJSONSerializer() },
-		"Gob":  func() Serializer { return NewGobSerializer() },
 	}
 
 	for serializerName, serializerFactory := range serializers {
@@ -573,15 +572,13 @@ func TestSerializer(t *testing.T) {
 			RegisterWorkflow(executor, serializerGetEventWorkflow)
 			RegisterWorkflow(executor, serializerRecoveryWorkflow)
 			RegisterWorkflow(executor, serializerInterfaceValueWorkflow)
-			if serializerName == "JSON" {
-				// Cannot register "any" workflow with Gob serializer
-				RegisterWorkflow(executor, serializerAnyValueWorkflow)
-				RegisterWorkflow(executor, serializerAnySenderWorkflow)
-				RegisterWorkflow(executor, serializerAnyReceiverWorkflow)
-				RegisterWorkflow(executor, serializerAnySetEventWorkflow)
-				RegisterWorkflow(executor, serializerAnyGetEventWorkflow)
-				RegisterWorkflow(executor, serializerAnyRecoveryWorkflow)
-			}
+			// Register any-type workflows (JSON-only runtime)
+			RegisterWorkflow(executor, serializerAnyValueWorkflow)
+			RegisterWorkflow(executor, serializerAnySenderWorkflow)
+			RegisterWorkflow(executor, serializerAnyReceiverWorkflow)
+			RegisterWorkflow(executor, serializerAnySetEventWorkflow)
+			RegisterWorkflow(executor, serializerAnyGetEventWorkflow)
+			RegisterWorkflow(executor, serializerAnyRecoveryWorkflow)
 
 			err := Launch(executor)
 			require.NoError(t, err)
@@ -606,9 +603,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test workflow with any type and comprehensive data structure
 			t.Run("ComprehensiveAnyValues", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 				input := TestWorkflowData{
 					ID:       "any-test-id",
 					Message:  "any test message",
@@ -697,9 +691,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test nil values with any type workflow
 			t.Run("NilValuesAny", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 				handle, err := RunWorkflow(executor, serializerAnyValueWorkflow, nil)
 				require.NoError(t, err, "Nil any workflow execution failed")
 
@@ -769,9 +760,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test Send/Recv with any type
 			t.Run("SendRecvAny", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 				input := TestWorkflowData{
 					ID:       "sendrecv-any-test-id",
 					Message:  "any test message",
@@ -786,9 +774,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test SetEvent/GetEvent with any type
 			t.Run("SetGetEventAny", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 				input := TestWorkflowData{
 					ID:       "event-any-test-id",
 					Message:  "any event message",
@@ -820,9 +805,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test workflow recovery with any type
 			t.Run("WorkflowRecoveryAny", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 
 				serializerAnyRecoveryStartEvent = NewEvent()
 				serializerAnyRecoveryEvent = NewEvent()
@@ -862,9 +844,6 @@ func TestSerializer(t *testing.T) {
 
 			// Test queued workflow with any type
 			t.Run("QueuedWorkflowAny", func(t *testing.T) {
-				if serializerName == "Gob" {
-					t.Skip("Skipping test for Gob serializer due to Gob limitations with interface types")
-				}
 
 				input := TestWorkflowData{
 					ID:       "queued-any-test-id",
@@ -896,7 +875,6 @@ func TestSerializer(t *testing.T) {
 // Test serializer interface compliance
 func TestSerializerInterface(t *testing.T) {
 	// Test that both serializers implement the Serializer interface
-	var _ Serializer = (*GobSerializer)(nil)
 	var _ Serializer = (*JSONSerializer)(nil)
 }
 
@@ -920,25 +898,9 @@ func TestSerializerConfiguration(t *testing.T) {
 		}
 	})
 
-	// Test Gob serializer configuration
-	t.Run("GobSerializer", func(t *testing.T) {
-		config := Config{
-			DatabaseURL: getDatabaseURL(),
-			AppName:     "test-app",
-			Serializer:  NewGobSerializer(),
-		}
-
-		executor, err := NewDBOSContext(context.Background(), config)
-		require.NoError(t, err, "Failed to create DBOS context with Gob serializer")
-
-		// Verify the serializer is set in the context
-		if dbosCtx, ok := executor.(*dbosContext); ok {
-			assert.NotNil(t, dbosCtx.serializer, "Gob serializer should be configured")
-			assert.IsType(t, &GobSerializer{}, dbosCtx.serializer, "Should be GobSerializer type")
-		}
-	})
+	// Removed Gob serializer configuration test
 
-	// Test default serializer (should be Gob)
+	// Test default serializer (should be JSON)
 	t.Run("DefaultSerializer", func(t *testing.T) {
 		config := Config{
 			DatabaseURL: getDatabaseURL(),
@@ -952,7 +914,7 @@ func TestSerializerConfiguration(t *testing.T) {
 		// Verify the default serializer is Gob
 		if dbosCtx, ok := executor.(*dbosContext); ok {
 			assert.NotNil(t, dbosCtx.serializer, "Default serializer should be configured")
-			assert.IsType(t, &GobSerializer{}, dbosCtx.serializer, "Default should be GobSerializer")
+			assert.IsType(t, &JSONSerializer{}, dbosCtx.serializer, "Default should be JSONSerializer")
 		}
 	})
 }