From cdeeb6d20fb92ff842f342263aef87c4b47e85b7 Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Fri, 30 Oct 2026 16:32:39 -0700 Subject: [PATCH 1/6] Add cross-language feature drivers and encoded header regression --- README.md | 33 +++ cmd/cmd.go | 1 + cmd/prepare.go | 7 +- cmd/run.go | 20 +- cmd/run_cross_language.go | 195 ++++++++++++++++++ cmd/run_cross_language_test.go | 126 +++++++++++ cmd/run_feature.go | 34 ++- cmd/run_typescript.go | 39 +++- dotnet.csproj | 2 + features/tracing/encoded_headers/README.md | 46 +++++ features/tracing/encoded_headers/config.json | 3 + .../tracing/encoded_headers/driver/main.go | 37 ++++ features/tracing/encoded_headers/feature.cs | 94 +++++++++ features/tracing/encoded_headers/feature.ts | 49 +++++ features/tracing/encoded_headers/workflow.ts | 7 + .../dotnet/Temporalio.Features.Harness/App.cs | 13 +- .../Temporalio.Features.Harness/Runner.cs | 42 ++-- harness/go/cmd/run.go | 1 + harness/go/crosslanguage/driver.go | 116 +++++++++++ harness/go/crosslanguage/driver_test.go | 88 ++++++++ harness/ts/harness.ts | 19 +- harness/ts/main.ts | 6 + package-lock.json | 96 +++++++++ package.json | 4 + sdkbuild/typescript.go | 3 + 25 files changed, 1043 insertions(+), 38 deletions(-) create mode 100644 cmd/run_cross_language.go create mode 100644 cmd/run_cross_language_test.go create mode 100644 features/tracing/encoded_headers/README.md create mode 100644 features/tracing/encoded_headers/config.json create mode 100644 features/tracing/encoded_headers/driver/main.go create mode 100644 features/tracing/encoded_headers/feature.cs create mode 100644 features/tracing/encoded_headers/feature.ts create mode 100644 features/tracing/encoded_headers/workflow.ts create mode 100644 harness/go/crosslanguage/driver.go create mode 100644 harness/go/crosslanguage/driver_test.go diff --git a/README.md b/README.md index 659d4631..d835cc86 100644 --- a/README.md +++ b/README.md @@ -151,6 +151,39 @@ history checks are performed: Currently there are not ways for features to opt out of specific history checks. To opt out of all history checking for a specific run, use `--no-history-check`. +## Cross-language features + +A feature with `"crossLanguage": true` in its `config.json` has a conventional +`driver/` Go program and ordinary `feature.` participants. Run these +features with their own subcommand: + +```sh +go run . run-cross-language tracing/encoded_headers +``` + +The runner discovers participants from the files, prepares each participating SDK +once, and supplies the driver with prepared harness commands, a server, namespace, +and unique task-queue prefix through `FEATURE_CROSS_LANGUAGE`. The +`harness/go/crosslanguage` package reads this manifest and invokes harnesses in +`client` or `worker` roles. Workers announce readiness before clients are run. +The driver chooses scenarios, pairs, and assertions; the runner does not generate +a language matrix. A nonzero driver exit fails the feature in the normal summary. + +Use repeated `--sdk-version language=version-or-local-checkout` options to select +SDKs independently. For example: + +```sh +go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +Only the .NET and TypeScript harnesses currently expose separate roles. Other +languages can be added as features require them. Cross-language features own their +history assertions and do not use the single-language history comparison/generation +mechanism. This subcommand exposes SDK selection, server/namespace/TLS options, +and temporary-build retention, but not history-generation or prepared-directory flags. +The existing `run` and `prepare` subcommands continue to require `--lang` and select +only single-language features. + ## Writing Features Developers can write workflows and activities that represent a SDK "feature". These are organized into directories under diff --git a/cmd/cmd.go b/cmd/cmd.go index dfa42b73..2a872e6b 100644 --- a/cmd/cmd.go +++ b/cmd/cmd.go @@ -28,6 +28,7 @@ func NewApp() *cli.App { Commands: []*cli.Command{ prepareCmd(), runCmd(), + runCrossLanguageCmd(), buildImageCmd(), publishImageCmd(), latestSdkVersionCmd(), diff --git a/cmd/prepare.go b/cmd/prepare.go index 1551ddd2..7f5910c3 100644 --- a/cmd/prepare.go +++ b/cmd/prepare.go @@ -26,9 +26,10 @@ func prepareCmd() *cli.Command { // PrepareConfig is configuration for NewPreparer. type PrepareConfig struct { - DirName string - Lang string - Version string + DirName string + Lang string + Version string + crossLanguage bool } func (p *PrepareConfig) flags() []cli.Flag { diff --git a/cmd/run.go b/cmd/run.go index 6b849538..57cbeafc 100644 --- a/cmd/run.go +++ b/cmd/run.go @@ -155,9 +155,12 @@ type Runner struct { log log.Logger config RunConfig // Root of the features repo - rootDir string - createTime time.Time - program sdkbuild.Program + rootDir string + createTime time.Time + program sdkbuild.Program + crossPrograms map[string]sdkbuild.Program + crossLanguage bool + crossVersions map[string]string } type runBatch struct { @@ -366,6 +369,10 @@ func (r *Runner) Run(ctx context.Context, patterns []string) error { } } } + return r.runFeatures(ctx, features, patterns) +} + +func (r *Runner) runFeatures(ctx context.Context, features []*RunFeature, patterns []string) error { features = r.filterFeaturesForExternalServer(features, patterns) if len(features) == 0 { return fmt.Errorf("no features matched") @@ -481,6 +488,10 @@ func (r *Runner) runBatch(ctx context.Context, batch runBatch) error { defer proxyServer.Close() } + if r.crossLanguage { + return r.runCrossLanguageBatch(ctx, config, batch) + } + l, err := net.Listen("tcp", summaryListenAddr) if err != nil { return err @@ -959,6 +970,9 @@ func (r *Runner) destroyTempDir() { if r.program != nil { _ = os.RemoveAll(r.program.Dir()) } + for _, program := range r.crossPrograms { + _ = os.RemoveAll(program.Dir()) + } } func normalizeLangName(lang string) (string, error) { diff --git a/cmd/run_cross_language.go b/cmd/run_cross_language.go new file mode 100644 index 00000000..4eb98d5d --- /dev/null +++ b/cmd/run_cross_language.go @@ -0,0 +1,195 @@ +package cmd + +import ( + "context" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" + "time" + + hcmd "github.com/temporalio/features/harness/go/cmd" + "github.com/temporalio/features/harness/go/crosslanguage" + "github.com/temporalio/features/sdkbuild" + "github.com/urfave/cli/v2" +) + +type CrossLanguageRunConfig struct { + RunConfig + SDKVersions cli.StringSlice +} + +func runCrossLanguageCmd() *cli.Command { + var config CrossLanguageRunConfig + return &cli.Command{ + Name: "run-cross-language", + Usage: "Run crossLanguage features using their custom drivers", + Flags: append([]cli.Flag{ + &cli.StringSliceFlag{ + Name: "sdk-version", Destination: &config.SDKVersions, + Usage: "SDK selection, e.g. cs=1.21.1 or ts=/path/to/sdk", + }, + &cli.BoolFlag{ + Name: "retain-temp-dir", Destination: &config.RetainTempDir, + Usage: "Do not delete temporary SDK and driver builds", + }, + }, config.dockerRunFlags()...), + Action: func(ctx *cli.Context) error { + versions, err := config.sdkVersions() + if err != nil { + return err + } + runner := NewRunner(config.RunConfig) + runner.crossLanguage, runner.crossVersions = true, versions + features, err := runner.GlobCrossLanguageFeatures(ctx.Args().Slice()) + if err != nil { + return err + } + return runner.runFeatures(ctx.Context, features, ctx.Args().Slice()) + }, + } +} + +func (config CrossLanguageRunConfig) sdkVersions() (map[string]string, error) { + versions := map[string]string{} + for _, selection := range config.SDKVersions.Value() { + lang, version, ok := strings.Cut(selection, "=") + lang, err := normalizeLangName(lang) + if !ok || err != nil || version == "" { + return nil, fmt.Errorf("invalid --sdk-version %q: expected language=version-or-path", selection) + } + if _, exists := versions[lang]; exists { + return nil, fmt.Errorf("duplicate --sdk-version for %s", lang) + } + versions[lang] = version + } + return versions, nil +} + +func (r *Runner) runCrossLanguageBatch(ctx context.Context, config RunConfig, batch runBatch) error { + restoreEnv := setNamespaceCapabilitiesEnv(config.NamespaceCapabilitiesJSON) + defer restoreEnv() + var summary Summary + var failed bool + for _, feature := range batch.Run.Features { + err := r.runCrossLanguageFeature(ctx, config, feature, r.crossVersions) + entry := SummaryEntry{Name: feature.SummaryName(), Outcome: FeaturePassed} + if err != nil { + entry.Outcome, entry.Message = "FAILED", err.Error() + failed = true + } + summary = append(summary, entry) + } + label := batch.VariantName + if label == "" { + label = "default" + } + r.logFeatureSummary(label, summary) + if failed { + return fmt.Errorf("cross-language feature failed") + } + return nil +} + +func (r *Runner) runCrossLanguageFeature( + ctx context.Context, config RunConfig, feature hcmd.RunFeature, versions map[string]string, +) error { + ctx, cancel := context.WithTimeout(ctx, 10*time.Minute) + defer cancel() + dir := filepath.Join(r.rootDir, "features", filepath.FromSlash(feature.Dir)) + files, err := filepath.Glob(filepath.Join(dir, "feature.*")) + if err != nil { + return err + } + manifest := crosslanguage.Manifest{ + Feature: feature.Dir, TaskQueue: feature.TaskQueue, + Programs: map[string]crosslanguage.Program{}, + } + for _, file := range files { + lang := strings.TrimPrefix(filepath.Ext(file), ".") + if _, err := normalizeLangName(lang); err != nil { + continue + } + program, err := r.crossLanguageProgram(ctx, lang, versions[lang]) + if err != nil { + return fmt.Errorf("prepare %s: %w", lang, err) + } + args := []string{"--server", config.Server, "--namespace", config.Namespace} + for _, option := range [][2]string{ + {"--client-cert-path", config.ClientCertPath}, {"--client-key-path", config.ClientKeyPath}, + {"--ca-cert-path", config.CACertPath}, {"--tls-server-name", config.TLSServerName}, + {"--http-proxy-url", config.HTTPProxyURL}, + } { + if option[1] != "" { + args = append(args, option[:]...) + } + } + if lang == "ts" { + args = append([]string{"./tslib/harness/ts/main.js"}, args...) + } + command, err := program.NewCommand(ctx, args...) + if err != nil { + return err + } + manifest.Programs[lang] = crosslanguage.Program{Dir: command.Dir, Args: command.Args} + } + if len(manifest.Programs) == 0 { + return fmt.Errorf("%s has no feature. participants", feature.Dir) + } + buildDir, err := os.MkdirTemp(r.rootDir, "program-cross-driver-") + if err != nil { + return err + } + if !config.RetainTempDir { + defer os.RemoveAll(buildDir) + } + binary := filepath.Join(buildDir, "driver") + build := exec.CommandContext(ctx, "go", "build", "-o", binary, ".") + build.Dir = filepath.Join(dir, "driver") + build.Stdout, build.Stderr = os.Stdout, os.Stderr + if err := build.Run(); err != nil { + return fmt.Errorf("build %s/driver: %w", feature.Dir, err) + } + data, err := json.Marshal(manifest) + if err != nil { + return err + } + command := exec.CommandContext(ctx, binary) + command.Dir = dir + command.Env = append(os.Environ(), crosslanguage.ManifestEnv+"="+string(data)) + command.Stdout, command.Stderr = os.Stdout, os.Stderr + command.Cancel = func() error { return command.Process.Signal(os.Interrupt) } + command.WaitDelay = 10 * time.Second + if err := command.Run(); err != nil { + return fmt.Errorf("%s driver: %w", feature.Dir, err) + } + return nil +} + +func (r *Runner) crossLanguageProgram(ctx context.Context, lang, version string) (sdkbuild.Program, error) { + if program := r.crossPrograms[lang]; program != nil { + return program, nil + } + p := NewPreparer(PrepareConfig{Lang: lang, Version: version, crossLanguage: true}) + p.rootDir = r.rootDir + var program sdkbuild.Program + var err error + switch lang { + case "cs": + program, err = p.BuildDotNetProgram(ctx) + case "ts": + program, err = p.BuildTypeScriptProgram(ctx) + default: + return nil, fmt.Errorf("cross-language harness roles are not implemented for %s yet", lang) + } + if err != nil { + return nil, err + } + if r.crossPrograms == nil { + r.crossPrograms = map[string]sdkbuild.Program{} + } + r.crossPrograms[lang] = program + return program, nil +} diff --git a/cmd/run_cross_language_test.go b/cmd/run_cross_language_test.go new file mode 100644 index 00000000..6822ad14 --- /dev/null +++ b/cmd/run_cross_language_test.go @@ -0,0 +1,126 @@ +package cmd + +import ( + "context" + "os" + "os/exec" + "path/filepath" + "testing" + + hcmd "github.com/temporalio/features/harness/go/cmd" + "github.com/temporalio/features/sdkbuild" + "github.com/urfave/cli/v2" +) + +func TestCrossLanguageFeatureDiscovery(t *testing.T) { + root := t.TempDir() + for path, contents := range map[string]string{ + "features/tracing/encoded/config.json": `{"crossLanguage":true}`, + "features/tracing/encoded/feature.cs": "", + "features/tracing/encoded/feature.ts": "", + "features/tracing/plain/feature.ts": "", + "features/tracing/plain/config.json": `{}`, + } { + path = filepath.Join(root, path) + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(path, []byte(contents), 0644); err != nil { + t.Fatal(err) + } + } + for _, test := range []struct { + lang, pattern, want string + }{ + {"", "", "tracing/encoded"}, + {"", "features/tracing/encoded", "tracing/encoded"}, + {"", "tracing/encoded/config.json", "tracing/encoded"}, + {"ts", "", "tracing/plain"}, + {"cs", "", ""}, + {"ts", "tracing/encoded", ""}, + } { + runner := NewRunner(RunConfig{PrepareConfig: PrepareConfig{Lang: test.lang}}) + runner.rootDir = root + var patterns []string + if test.pattern != "" { + patterns = []string{test.pattern} + } + var features []*RunFeature + var err error + if test.lang == "" { + features, err = runner.GlobCrossLanguageFeatures(patterns) + } else { + features, err = runner.GlobFeatures(patterns) + } + if err != nil { + t.Fatal(err) + } + if test.want == "" { + if len(features) != 0 { + t.Fatalf("lang=%q pattern=%q: unwanted features %v", test.lang, test.pattern, features) + } + } else if len(features) != 1 || features[0].Dir != test.want { + t.Fatalf("lang=%q pattern=%q: got %v, want %s", test.lang, test.pattern, features, test.want) + } + } +} + +func TestCrossLanguageSDKSelections(t *testing.T) { + for _, selections := range [][]string{{"ts"}, {"ts="}, {"unknown=1"}, {"ts=1", "typescript=2"}} { + config := CrossLanguageRunConfig{SDKVersions: *cli.NewStringSlice(selections...)} + if _, err := config.sdkVersions(); err == nil { + t.Fatalf("accepted invalid SDK selections %v", selections) + } + } + config := CrossLanguageRunConfig{SDKVersions: *cli.NewStringSlice("dotnet=1.21.1", "ts=/local/sdk")} + versions, err := config.sdkVersions() + if err != nil || versions["cs"] != "1.21.1" || versions["ts"] != "/local/sdk" { + t.Fatalf("unexpected selections %v, %v", versions, err) + } +} + +type preparedCrossLanguageProgram struct{ dir string } + +func (p preparedCrossLanguageProgram) Dir() string { return p.dir } +func (p preparedCrossLanguageProgram) NewCommand(ctx context.Context, args ...string) (*exec.Cmd, error) { + command := exec.CommandContext(ctx, "unused-harness", args...) + command.Dir = p.dir + return command, nil +} + +func TestCrossLanguageDriverExitControlsFeatureOutcome(t *testing.T) { + for _, exit := range []string{"0", "7"} { + t.Run(exit, func(t *testing.T) { + root := t.TempDir() + for path, contents := range map[string]string{ + "go.mod": "module driver-test\n\ngo 1.26.0\n", + "features/sample/feature.ts": "", + "features/sample/driver/main.go": `package main +import ("os"; "strings") +func main() { + if !strings.Contains(os.Getenv("FEATURE_CROSS_LANGUAGE"), "\"Feature\":\"sample\"") { os.Exit(8) } + os.Exit(` + exit + `) +}`, + } { + path = filepath.Join(root, path) + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(path, []byte(contents), 0644); err != nil { + t.Fatal(err) + } + } + runner := NewRunner(RunConfig{}) + runner.rootDir = root + runner.crossPrograms = map[string]sdkbuild.Program{ + "ts": preparedCrossLanguageProgram{root}, + } + err := runner.runCrossLanguageBatch(t.Context(), RunConfig{}, runBatch{ + Run: &hcmd.Run{Features: []hcmd.RunFeature{{Dir: "sample", TaskQueue: "queue"}}}, + }) + if (err != nil) != (exit != "0") { + t.Fatalf("driver exit=%s: unexpected result %v", exit, err) + } + }) + } +} diff --git a/cmd/run_feature.go b/cmd/run_feature.go index 10a773d4..5d39c7a8 100644 --- a/cmd/run_feature.go +++ b/cmd/run_feature.go @@ -19,12 +19,27 @@ type RunFeature struct { // GlobFeatures collects all features for this runner using the given patterns // or all features if no patterns given. func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { + return r.globFeatures(patterns, false) +} + +func (r *Runner) GlobCrossLanguageFeatures(patterns []string) ([]*RunFeature, error) { + return r.globFeatures(patterns, true) +} + +func (r *Runner) globFeatures(patterns []string, crossLanguage bool) ([]*RunFeature, error) { // Collect all feature dirs that have a lang entry var features []*RunFeature featuresDir := filepath.Join(r.rootDir, "features") - err := filepath.WalkDir(featuresDir, func(path string, _ fs.DirEntry, _ error) error { + err := filepath.WalkDir(featuresDir, func(path string, _ fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } // Only files that are feature + ext matter - if filepath.Base(path) != "feature."+r.config.Lang { + name := "feature." + r.config.Lang + if crossLanguage { + name = "config.json" + } + if filepath.Base(path) != name { return nil } @@ -35,6 +50,13 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { return err } dir = filepath.ToSlash(dir) + feature := &RunFeature{Dir: dir} + if err := feature.Config.LoadFromDir(filepath.Dir(path)); err != nil { + return fmt.Errorf("failed reading config from %v: %w", path, err) + } + if feature.Config.CrossLanguage != crossLanguage { + return nil + } // If no patterns present, all match. Otherwise, check dir or file on each. if len(patterns) > 0 { @@ -43,7 +65,7 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { pattern = strings.TrimPrefix(pattern, "features/") match, err := filepath.Match(pattern, dir) if !match && err == nil { - match, err = filepath.Match(pattern, dir+"/feature."+r.config.Lang) + match, err = filepath.Match(pattern, dir+"/"+name) } if err != nil { return fmt.Errorf("invalid pattern %q: %w", pattern, err) @@ -57,12 +79,6 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { } } - // Load config - feature := &RunFeature{Dir: dir} - if err := feature.Config.LoadFromDir(filepath.Dir(path)); err != nil { - return fmt.Errorf("failed reading config from %v: %w", path, err) - } - // If there's a min version, check we're within it if r.config.Lang == "go" && r.config.Version != "" && feature.Config.Go.MinVersion != "" { if semver.Compare(r.config.Version, feature.Config.Go.MinVersion) < 0 { diff --git a/cmd/run_typescript.go b/cmd/run_typescript.go index 967e98ed..6fd8e751 100644 --- a/cmd/run_typescript.go +++ b/cmd/run_typescript.go @@ -6,6 +6,7 @@ import ( "fmt" "os" "path/filepath" + "strings" "github.com/temporalio/features/harness/go/cmd" "github.com/temporalio/features/sdkbuild" @@ -32,10 +33,42 @@ func (p *Preparer) BuildTypeScriptProgram(ctx context.Context) (sdkbuild.Program } } + var dependencies map[string]string + var excludes []string + if p.config.crossLanguage { + tracingVersion := strings.TrimPrefix(version, "v") + if strings.ContainsAny(version, `/\`) { + path, err := filepath.Abs(filepath.Join(version, "contrib", "interceptors-opentelemetry")) + if err != nil { + return nil, err + } + tracingVersion = "link:" + path + } + dependencies = map[string]string{ + "@temporalio/interceptors-opentelemetry": tracingVersion, + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", + } + } else { + // Cross-language participants may depend on newer SDK APIs than the ordinary + // features selected for a historical single-language run. + runner := NewRunner(RunConfig{}) + runner.rootDir = p.rootDir + features, err := runner.GlobCrossLanguageFeatures(nil) + if err != nil { + return nil, err + } + for _, feature := range features { + excludes = append(excludes, "../features/"+feature.Dir) + } + } prog, err := sdkbuild.BuildTypeScriptProgram(ctx, sdkbuild.BuildTypeScriptProgramOptions{ - BaseDir: p.rootDir, - DirName: p.config.DirName, - Version: version, + BaseDir: p.rootDir, + DirName: p.config.DirName, + Version: version, + MoreDependencies: dependencies, + AdditionalExcludes: excludes, TSConfigPaths: map[string][]string{ "@temporalio/harness": {"./tslib/harness/ts/harness.js", "../harness/ts/harness.ts"}, }, diff --git a/dotnet.csproj b/dotnet.csproj index cc990406..fa900119 100644 --- a/dotnet.csproj +++ b/dotnet.csproj @@ -39,10 +39,12 @@ + + diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md new file mode 100644 index 00000000..77c483ad --- /dev/null +++ b/features/tracing/encoded_headers/README.md @@ -0,0 +1,46 @@ +# Encoded tracing headers across languages + +Reproduces [.NET → TypeScript encoded tracing headers](https://github.com/temporalio/sdk-typescript/issues/514#issuecomment-6259375934). +A .NET client using its tracing interceptor and payload codec starts a workflow +on a TypeScript OpenTelemetry worker using the matching codec. + +The driver currently runs only .NET → TypeScript. It requires the workflow to +complete without Workflow Task failures, round-trip its input/result, and retain +the caller's trace identity. It verifies that the history's `_tracer-data` header +was actually codec-encoded. Silently discarding an unreadable trace header is not +a pass. + +Both codecs wrap serialized protobuf `Payload` bytes with XOR `0x5a`, setting +`encoding` to `binary/encrypted`. This is a test codec, **not encryption**. +Both reject double encoding. + +From the repository root, with the usual Go, .NET, Node and Corepack/pnpm prerequisites: + +```sh +go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=1.25.0 tracing/encoded_headers +``` + +This is a **failing regression test** with those releases: TypeScript raises +`Unknown encoding: binary/encrypted` in `extractContextFromHeaders`. It is not +marked as an expected failure. The workflow has a 15-second execution timeout; +the driver has a one-minute scenario deadline and prints the original task failure. + +To select SDK changes under development, replace either version with a checkout +path (relative paths are resolved from the repository root): + +```sh +go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +The TS feature requests header codec processing with `encodeHeaders: true`. +SDKs without that option ignore it and fail the test. There is no test interceptor +that decodes the header on the SDK's behalf. + +The runner reuses the normal SDK preparation and dev-server setup. The driver +launches the existing TS harness in worker-only mode and the .NET harness in +client-only mode. It stops the worker on success or failure. No external tracing +backend is used, and no C# source is embedded in the driver. + +Further languages and scenarios belong in this feature's driver and participants, +not in a Cartesian-product policy in the runner. Single-language history replay +is not applicable here; the .NET participant checks the actual TS execution history. diff --git a/features/tracing/encoded_headers/config.json b/features/tracing/encoded_headers/config.json new file mode 100644 index 00000000..8e492f94 --- /dev/null +++ b/features/tracing/encoded_headers/config.json @@ -0,0 +1,3 @@ +{ + "crossLanguage": true +} diff --git a/features/tracing/encoded_headers/driver/main.go b/features/tracing/encoded_headers/driver/main.go new file mode 100644 index 00000000..b194d80d --- /dev/null +++ b/features/tracing/encoded_headers/driver/main.go @@ -0,0 +1,37 @@ +package main + +import ( + "context" + "fmt" + "os" + "os/signal" + "time" + + "github.com/temporalio/features/harness/go/crosslanguage" +) + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func run() error { + ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) + defer cancel() + ctx, timeout := context.WithTimeout(ctx, time.Minute) + defer timeout() + participants, err := crosslanguage.FromEnv() + if err != nil { + return err + } + queue := participants.TaskQueue + "-cs-ts" + stop, err := participants.StartWorker(ctx, "ts", queue) + if err != nil { + return err + } + defer stop() + fmt.Println("Testing encoded tracing headers: .NET client → TypeScript worker") + return participants.RunClient(ctx, "cs", queue) +} diff --git a/features/tracing/encoded_headers/feature.cs b/features/tracing/encoded_headers/feature.cs new file mode 100644 index 00000000..c4ecfe18 --- /dev/null +++ b/features/tracing/encoded_headers/feature.cs @@ -0,0 +1,94 @@ +namespace tracing.encoded_headers; + +using System.Diagnostics; +using System.Text.Json; +using Google.Protobuf; +using OpenTelemetry.Context.Propagation; +using Temporalio.Api.Common.V1; +using Temporalio.Client; +using Temporalio.Converters; +using Temporalio.Extensions.OpenTelemetry; +using Temporalio.Features.Harness; +using Temporalio.Worker; + +public class Feature : IFeature +{ + public void ConfigureClient(Runner runner, TemporalClientConnectOptions options) + { + options.DataConverter = DataConverter.Default with { PayloadCodec = new WrappingCodec() }; + options.Interceptors = new[] + { + new TracingInterceptor(new() { Propagator = new TraceContextPropagator() }), + }; + } + + public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) { } + + public async Task ExecuteAsync(Runner runner) + { + var clientSourceName = TracingInterceptor.ClientSource.Name; + using var listener = new ActivityListener + { + ShouldListenTo = source => source.Name == "header-codec-feature" || + source.Name == clientSourceName, + Sample = (ref ActivityCreationOptions _) => ActivitySamplingResult.AllDataAndRecorded, + }; + ActivitySource.AddActivityListener(listener); + using var source = new ActivitySource("header-codec-feature"); + using var parent = source.StartActivity("dotnet-caller")!; + var options = runner.NewWorkflowOptions(); + options.ExecutionTimeout = TimeSpan.FromSeconds(15); + var handle = await runner.Client.StartWorkflowAsync("workflow", new object?[] { "hello" }, options); + try + { + var history = await handle.FetchHistoryAsync(); + var header = history.Events.First().WorkflowExecutionStartedEventAttributes.Header.Fields["_tracer-data"]; + Assert.Equal(WrappingCodec.EncodingName, header.Metadata["encoding"].ToStringUtf8()); + var decoded = (await new WrappingCodec().DecodeAsync(new[] { header })).Single(); + var carrier = JsonSerializer.Deserialize>(decoded.Data.ToStringUtf8())!; + Assert.Equal(parent.TraceId.ToHexString(), carrier["traceparent"].Split('-')[1]); + + var result = await handle.GetResultAsync>().WaitAsync(TimeSpan.FromSeconds(30)); + Assert.Equal("hello", result["message"]); + Assert.Equal(parent.TraceId.ToHexString(), result["traceId"]); + history = await handle.FetchHistoryAsync(); + Assert.DoesNotContain(history.Events, evt => evt.WorkflowTaskFailedEventAttributes != null); + return null; + } + catch + { + // Preserve the extraction error in diagnostics instead of reporting only an execution timeout. + foreach (var evt in (await handle.FetchHistoryAsync()).Events) + { + if (evt.WorkflowTaskFailedEventAttributes is { } failed) + { + runner.Logger.LogError("Workflow Task failed: {Failure}", failed.Failure); + } + } + throw; + } + } + + sealed class WrappingCodec : IPayloadCodec + { + public const string EncodingName = "binary/encrypted"; + + public Task> EncodeAsync(IReadOnlyCollection payloads) => + Task.FromResult>(payloads.Select(payload => + { + Assert.NotEqual(EncodingName, payload.Metadata["encoding"].ToStringUtf8()); + return new Payload + { + Metadata = { ["encoding"] = ByteString.CopyFromUtf8(EncodingName) }, + Data = ByteString.CopyFrom(payload.ToByteArray().Select(b => (byte)(b ^ 0x5a)).ToArray()), + }; + }).ToArray()); + + public Task> DecodeAsync(IReadOnlyCollection payloads) => + Task.FromResult>(payloads.Select(payload => + { + Assert.Equal(EncodingName, payload.Metadata["encoding"].ToStringUtf8()); + return Payload.Parser.ParseFrom(payload.Data.Select(b => (byte)(b ^ 0x5a)).ToArray()); + }).ToArray()); + } +} diff --git a/features/tracing/encoded_headers/feature.ts b/features/tracing/encoded_headers/feature.ts new file mode 100644 index 00000000..8def8141 --- /dev/null +++ b/features/tracing/encoded_headers/feature.ts @@ -0,0 +1,49 @@ +import { Resource } from '@opentelemetry/resources'; +import { InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'; +import { Feature } from '@temporalio/harness'; +import { Payload, PayloadCodec } from '@temporalio/common'; +import { temporal } from '@temporalio/proto'; +import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry'; + +const encoding = 'binary/encrypted'; +const payloadProto = temporal.api.common.v1.Payload; +const xor = (data: Uint8Array): Uint8Array => data.map((byte) => byte ^ 0x5a); + +class WrappingCodec implements PayloadCodec { + async encode(payloads: Payload[]): Promise { + return payloads.map((payload) => { + if (Buffer.from(payload.metadata?.encoding ?? []).toString() === encoding) { + throw new Error('Payload encoded twice'); + } + return { + metadata: { encoding: Buffer.from(encoding) }, + data: xor(payloadProto.encode(payload).finish()), + }; + }); + } + + async decode(payloads: Payload[]): Promise { + return payloads.map((payload) => { + if (Buffer.from(payload.metadata?.encoding ?? []).toString() !== encoding) { + throw new Error('Expected an encoded payload'); + } + return payloadProto.decode(xor(payload.data!)); + }); + } +} + +// Keep the codec on the worker boundary; an interceptor workaround would mask the regression. +const dataConverter = { payloadCodecs: [new WrappingCodec()], encodeHeaders: true }; + +export const feature = new Feature({ + workflowsPath: require.resolve('./workflow'), + dataConverter, + workerOptions: { + plugins: [ + new OpenTelemetryPlugin({ + resource: new Resource({ 'service.name': 'encoded-headers-feature' }), + spanProcessor: new SimpleSpanProcessor(new InMemorySpanExporter()), + }), + ], + }, +}); diff --git a/features/tracing/encoded_headers/workflow.ts b/features/tracing/encoded_headers/workflow.ts new file mode 100644 index 00000000..116c81b7 --- /dev/null +++ b/features/tracing/encoded_headers/workflow.ts @@ -0,0 +1,7 @@ +import { context, trace } from '@opentelemetry/api'; + +export async function workflow(message: string): Promise<{ message: string; traceId: string }> { + const span = trace.getSpan(context.active()); + if (!span) throw new Error('No active workflow tracing span'); + return { message, traceId: span.spanContext().traceId }; +} diff --git a/harness/dotnet/Temporalio.Features.Harness/App.cs b/harness/dotnet/Temporalio.Features.Harness/App.cs index c897197a..277f4b10 100644 --- a/harness/dotnet/Temporalio.Features.Harness/App.cs +++ b/harness/dotnet/Temporalio.Features.Harness/App.cs @@ -39,6 +39,11 @@ public static class App name: "--tls-server-name", description: "TLS server name to use for verification"); + private static readonly Option roleOption = new( + name: "--role", + getDefaultValue: () => "all", + description: "Run all, client, or worker portions of a feature"); + private static readonly Argument< List<(string Dir, string TaskQueue, string? NexusEndpoint)>> featuresArgument = new( name: "features", @@ -72,6 +77,7 @@ private static Command CreateCommand() cmd.AddOption(caCertPathOption); cmd.AddOption(httpProxyUrlOption); cmd.AddOption(tlsServerNameOption); + cmd.AddOption(roleOption); cmd.AddArgument(featuresArgument); cmd.SetHandler(RunCommandAsync); return cmd; @@ -79,6 +85,11 @@ private static Command CreateCommand() private static async Task RunCommandAsync(InvocationContext ctx) { + var role = ctx.ParseResult.GetValueForOption(roleOption)!; + if (role is not ("all" or "client" or "worker")) + { + throw new ArgumentException("--role must be all, client, or worker"); + } // Create logger factory using var loggerFactory = LoggerFactory.Create(builder => builder.AddSimpleConsole( options => @@ -135,7 +146,7 @@ private static async Task RunCommandAsync(InvocationContext ctx) feature, loggerFactory, ctx.ParseResult.GetValueForOption(httpProxyUrlOption) - ).RunAsync(ctx.GetCancellationToken()); + ).RunAsync(ctx.GetCancellationToken(), role); } catch (TestSkippedException e) { diff --git a/harness/dotnet/Temporalio.Features.Harness/Runner.cs b/harness/dotnet/Temporalio.Features.Harness/Runner.cs index 03043e72..55fe67a5 100644 --- a/harness/dotnet/Temporalio.Features.Harness/Runner.cs +++ b/harness/dotnet/Temporalio.Features.Harness/Runner.cs @@ -82,29 +82,43 @@ internal Runner( /// Run the feature with the given cancellation token. /// /// + /// Run both portions, only the client, or only the worker. /// - public async Task RunAsync(CancellationToken cancellationToken) + public async Task RunAsync(CancellationToken cancellationToken, string role = "all") { Logger.LogInformation("Executing feature {Feature}", PreparedFeature.Dir); runCancelToken = cancellationToken; client = await TemporalClient.ConnectAsync(ClientOptions); Feature.ConfigureWorker(this, WorkerOptions); - StartWorker(); - - var run = await Feature.ExecuteAsync(this); - if (run == null) + if (role != "client") { - Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir); - return; + StartWorker(); } - - Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir); - await Feature.CheckResultAsync(this, run); - await Feature.CheckHistoryAsync(this, run); - - if (workerState != null) + try { - await workerState.StopAndWait(); + if (role == "worker") + { + Console.WriteLine("FEATURE_WORKER_READY"); + await Task.Delay(Timeout.Infinite, cancellationToken); + return; + } + var run = await Feature.ExecuteAsync(this); + if (run == null) + { + Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir); + return; + } + Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir); + await Feature.CheckResultAsync(this, run); + if (role == "all") + { + // A client-only run may target another SDK's workflow implementation. + await Feature.CheckHistoryAsync(this, run); + } + } + finally + { + await StopWorker(); } } diff --git a/harness/go/cmd/run.go b/harness/go/cmd/run.go index baef4e77..5c0b6923 100644 --- a/harness/go/cmd/run.go +++ b/harness/go/cmd/run.go @@ -101,6 +101,7 @@ func (r RunFeature) SummaryName() string { // RunFeatureConfig is config from config.json. type RunFeatureConfig struct { + CrossLanguage bool `json:"crossLanguage"` NoWorkflow bool `json:"noWorkflow"` NeedsNexusEndpoint bool `json:"needsNexusEndpoint"` Go RunFeatureConfigGo `json:"go"` diff --git a/harness/go/crosslanguage/driver.go b/harness/go/crosslanguage/driver.go new file mode 100644 index 00000000..890a7378 --- /dev/null +++ b/harness/go/crosslanguage/driver.go @@ -0,0 +1,116 @@ +// Package crosslanguage lets feature drivers invoke prepared language harnesses. +package crosslanguage + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "os" + "os/exec" +) + +const ManifestEnv = "FEATURE_CROSS_LANGUAGE" +const WorkerReady = "FEATURE_WORKER_READY" + +type Program struct { + Dir string + Args []string +} + +type Manifest struct { + Feature string + TaskQueue string + Programs map[string]Program +} + +func FromEnv() (*Manifest, error) { + var manifest Manifest + if err := json.Unmarshal([]byte(os.Getenv(ManifestEnv)), &manifest); err != nil { + return nil, fmt.Errorf("read runner manifest: %w", err) + } + return &manifest, nil +} + +func (m *Manifest) command(ctx context.Context, lang, role, queue string) (*exec.Cmd, error) { + program, ok := m.Programs[lang] + if !ok || len(program.Args) == 0 { + return nil, fmt.Errorf("feature has no prepared %s participant", lang) + } + args := append(append([]string{}, program.Args[1:]...), "--role", role, m.Feature+":"+queue) + cmd := exec.CommandContext(ctx, program.Args[0], args...) + cmd.Dir = program.Dir + cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr + return cmd, nil +} + +func (m *Manifest) RunClient(ctx context.Context, lang, queue string) error { + cmd, err := m.command(ctx, lang, "client", queue) + if err != nil { + return err + } + if err := cmd.Run(); err != nil { + return fmt.Errorf("%s client: %w", lang, err) + } + return nil +} + +// StartWorker waits for harness readiness. The returned function stops and reaps +// the process; drivers should defer it before executing any client scenarios. +func (m *Manifest) StartWorker(ctx context.Context, lang, queue string) (func(), error) { + ctx, cancel := context.WithCancel(ctx) + cmd, err := m.command(ctx, lang, "worker", queue) + if err != nil { + cancel() + return nil, err + } + cmd.Stdout = nil + stdout, err := cmd.StdoutPipe() + if err != nil { + cancel() + return nil, err + } + if err := cmd.Start(); err != nil { + cancel() + return nil, err + } + ready, done := make(chan struct{}), make(chan struct{}) + var runErr error + go func() { + scanner := bufio.NewScanner(stdout) + scanner.Buffer(make([]byte, 4096), 1024*1024) + announced := false + for scanner.Scan() { + line := scanner.Text() + if line == WorkerReady && !announced { + close(ready) + announced = true + } else { + fmt.Println(line) + } + } + if scanner.Err() != nil { + // A stopped reader can leave the worker blocked writing to its full pipe. + cancel() + } + runErr = cmd.Wait() + if scanner.Err() != nil { + runErr = fmt.Errorf("read worker output: %w", scanner.Err()) + } + close(done) + }() + stop := func() { + cancel() + <-done + } + select { + case <-ready: + return stop, nil + case <-done: + stop() + return nil, fmt.Errorf("%s worker exited before readiness: %v", lang, runErr) + case <-ctx.Done(): + stop() + return nil, ctx.Err() + } +} diff --git a/harness/go/crosslanguage/driver_test.go b/harness/go/crosslanguage/driver_test.go new file mode 100644 index 00000000..8330ded2 --- /dev/null +++ b/harness/go/crosslanguage/driver_test.go @@ -0,0 +1,88 @@ +package crosslanguage + +import ( + "context" + "fmt" + "os" + "os/signal" + "strings" + "testing" + "time" +) + +func helperManifest(t *testing.T, behavior string) Manifest { + t.Helper() + t.Setenv("CROSS_LANGUAGE_TEST_PROCESS", behavior) + return Manifest{ + Feature: "tracing/headers", + Programs: map[string]Program{ + "test": {Args: []string{os.Args[0], "-test.run=^TestHarnessProcess$", "--"}}, + }, + } +} + +func TestWorkerReadinessAndCleanup(t *testing.T) { + manifest := helperManifest(t, "ready") + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + defer cancel() + stop, err := manifest.StartWorker(ctx, "test", "queue") + if err != nil { + t.Fatal(err) + } + stop() +} + +func TestWorkerExitsBeforeReadiness(t *testing.T) { + manifest := helperManifest(t, "exit") + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + defer cancel() + if _, err := manifest.StartWorker(ctx, "test", "queue"); err == nil || + !strings.Contains(err.Error(), "before readiness") { + t.Fatalf("expected readiness failure, got %v", err) + } +} + +func TestWorkerCanceledBeforeReadiness(t *testing.T) { + manifest := helperManifest(t, "wait") + ctx, cancel := context.WithCancel(t.Context()) + cancel() + if _, err := manifest.StartWorker(ctx, "test", "queue"); err == nil { + t.Fatal("canceled worker unexpectedly started") + } +} + +func TestClientRoleAndFailure(t *testing.T) { + for _, behavior := range []string{"client", "exit"} { + manifest := helperManifest(t, behavior) + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + err := manifest.RunClient(ctx, "test", "queue") + cancel() + if (err != nil) != (behavior == "exit") { + t.Fatalf("behavior=%s: unexpected result %v", behavior, err) + } + } +} + +func TestHarnessProcess(t *testing.T) { + behavior := os.Getenv("CROSS_LANGUAGE_TEST_PROCESS") + if behavior == "" { + return + } + switch behavior { + case "client": + args := strings.Join(os.Args, " ") + if !strings.Contains(args, "--role client tracing/headers:queue") { + os.Exit(2) + } + case "ready", "wait": + ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) + defer cancel() + if behavior == "ready" { + fmt.Println(WorkerReady) + fmt.Println(WorkerReady) + } + <-ctx.Done() + case "exit": + os.Exit(3) + } +} diff --git a/harness/ts/harness.ts b/harness/ts/harness.ts index 9c83ebf0..04797ae7 100644 --- a/harness/ts/harness.ts +++ b/harness/ts/harness.ts @@ -119,6 +119,7 @@ export class FeatureSource { } export interface RunnerOptions { + role?: 'all' | 'client' | 'worker'; address: string; namespace: string; proxyUrl?: string; @@ -179,9 +180,9 @@ export class Runner { }, ...feature.options.workerOptions, }; - const worker = await Worker.create(workerOpts); + const worker = options.role === 'client' ? undefined : await Worker.create(workerOpts); const workerRunPromise = (async () => { - await worker.run(); + if (worker) await worker.run(); })(); return new Runner( source, @@ -205,12 +206,19 @@ export class Runner { readonly connectionOpts: ConnectionOptions, readonly nativeConnection: NativeConnection, readonly nativeConnectionOpts: NativeConnectionOptions, - private _worker: Worker, + private _worker: Worker | undefined, readonly workerOpts: WorkerOptions, private _workerRunPromise: Promise, ) {} async run(): Promise { + if (this.options.role === 'worker') { + console.log('FEATURE_WORKER_READY'); + return await this._workerRunPromise; + } + if (this.options.role === 'client') { + return await this.runWorkflow(); + } if (this.feature.options.alternateRun) { return await this.feature.options.alternateRun(this); } else { @@ -253,6 +261,7 @@ export class Runner { } get worker(): Worker { + if (!this._worker) throw new IllegalStateError('Worker not started in client-only mode'); return this._worker; } @@ -263,7 +272,7 @@ export class Runner { async restartWorker(): Promise { this._worker = await Worker.create(this.workerOpts); this._workerRunPromise = (async () => { - await this._worker.run(); + await this.worker.run(); })(); } @@ -289,7 +298,7 @@ export class Runner { async close(): Promise { try { - this._worker.shutdown(); + this._worker?.shutdown(); } catch (err) { if (!(err instanceof IllegalStateError && err.message.includes('Not running'))) { throw err; diff --git a/harness/ts/main.ts b/harness/ts/main.ts index 15685046..72ace8f6 100644 --- a/harness/ts/main.ts +++ b/harness/ts/main.ts @@ -16,6 +16,7 @@ async function run() { .option('--ca-cert-path ', 'Path to a CA certificate for server verification') .option('--http-proxy-url ', 'HTTP proxy URL') .option('--tls-server-name ', 'TLS server name to use for verification') + .option('--role ', 'Run all, client, or worker portions of a feature', 'all') .argument('', 'Features as dir + ":" + task queue'); const opts = program.parse(process.argv).opts<{ @@ -26,9 +27,13 @@ async function run() { caCertPath: string; httpProxyUrl: string; tlsServerName: string; + role: 'all' | 'client' | 'worker'; featureAndTaskQueues: string[]; }>(); opts.featureAndTaskQueues = program.args; + if (!['all', 'client', 'worker'].includes(opts.role)) { + throw new Error('--role must be all, client, or worker'); + } console.log('Running TypeScript SDK version ' + pkg.version, 'against', opts.server); @@ -87,6 +92,7 @@ async function run() { proxyUrl: opts.httpProxyUrl, taskQueue, tlsConfig, + role: opts.role, }); await runner.run(); } catch (err) { diff --git a/package-lock.json b/package-lock.json index b8fd2229..f5846411 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,6 +9,9 @@ "@aws-sdk/client-s3": "^3.0.0", "@google-cloud/storage": "^7.0.0", "@grpc/grpc-js": "^1.12.4", + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", @@ -17,6 +20,7 @@ "@temporalio/external-storage-gcs-google-sdk": "^1.25.0", "@temporalio/external-storage-s3": "^1.25.0", "@temporalio/external-storage-s3-aws-sdk": "^1.25.0", + "@temporalio/interceptors-opentelemetry": "^1.25.0", "@temporalio/plugin": "^1.25.0", "@temporalio/proto": "^1.25.0", "@temporalio/worker": "^1.25.0", @@ -1284,6 +1288,73 @@ "node": ">=12.4.0" } }, + "node_modules/@opentelemetry/api": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", + "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@opentelemetry/core": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz", + "integrity": "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/resources": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz", + "integrity": "sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/sdk-trace-base": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz", + "integrity": "sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==", + "deprecated": "Use @opentelemetry/sdk-trace package", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/resources": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/semantic-conventions": { + "version": "1.28.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz", + "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + } + }, "node_modules/@protobuf-ts/protoc": { "version": "2.11.1", "resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.11.1.tgz", @@ -1815,6 +1886,31 @@ "protobufjs": "^8.7.1" } }, + "node_modules/@temporalio/interceptors-opentelemetry": { + "version": "1.25.0", + "resolved": "https://registry.npmjs.org/@temporalio/interceptors-opentelemetry/-/interceptors-opentelemetry-1.25.0.tgz", + "integrity": "sha512-6nROrw3uOJvGi5njtjlA/szZBCEGKQHSpWg/kJ5NqGjNmAM6KLWe7XQcJGH5s8aIGtUlq0k6sAQFAH38ATKTEg==", + "license": "MIT", + "dependencies": { + "@opentelemetry/api": "^1.9.0", + "@opentelemetry/core": "^1.25.1", + "@opentelemetry/resources": "^1.25.1", + "@opentelemetry/sdk-trace-base": "^1.25.1", + "@temporalio/plugin": "1.25.0" + }, + "engines": { + "node": ">= 20.3.0" + }, + "peerDependencies": { + "@temporalio/common": "1.25.0", + "@temporalio/workflow": "1.25.0" + }, + "peerDependenciesMeta": { + "@temporalio/workflow": { + "optional": true + } + } + }, "node_modules/@temporalio/nexus": { "version": "1.25.0", "resolved": "https://registry.npmjs.org/@temporalio/nexus/-/nexus-1.25.0.tgz", diff --git a/package.json b/package.json index c4def422..e6c21585 100644 --- a/package.json +++ b/package.json @@ -11,10 +11,14 @@ "@aws-sdk/client-s3": "^3.0.0", "@google-cloud/storage": "^7.0.0", "@grpc/grpc-js": "^1.12.4", + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", "@temporalio/common": "^1.25.0", + "@temporalio/interceptors-opentelemetry": "^1.25.0", "@temporalio/external-storage-gcs": "^1.25.0", "@temporalio/external-storage-gcs-google-sdk": "^1.25.0", "@temporalio/external-storage-s3": "^1.25.0", diff --git a/sdkbuild/typescript.go b/sdkbuild/typescript.go index 614e90d4..8c32bb4c 100644 --- a/sdkbuild/typescript.go +++ b/sdkbuild/typescript.go @@ -33,6 +33,8 @@ type BuildTypeScriptProgramOptions struct { Includes []string // If present, overrides the default "exclude" array in tsconfig.json. Excludes []string + // Additional exclusions appended to the default or overridden exclude array. + AdditionalExcludes []string // If present, add additional dependencies -> version string to package.json. MoreDependencies map[string]string // If present, custom writers that will capture stdout/stderr. @@ -194,6 +196,7 @@ func BuildTypeScriptProgram(ctx context.Context, options BuildTypeScriptProgramO if len(options.Excludes) > 0 { excludes = options.Excludes } + excludes = append(excludes, options.AdditionalExcludes...) quotedIncludes := make([]string, len(includes)) for i, include := range includes { quotedIncludes[i] = strconv.Quote(include) From 5f040bd72be3eb631339fcdd01b3b32d172e919f Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Fri, 30 Oct 2026 16:56:40 -0700 Subject: [PATCH 2/6] Use worker-scoped header codecs in cross-language feature --- features/tracing/encoded_headers/README.md | 2 +- features/tracing/encoded_headers/feature.ts | 21 +++++++++++---------- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md index 77c483ad..e858a046 100644 --- a/features/tracing/encoded_headers/README.md +++ b/features/tracing/encoded_headers/README.md @@ -32,7 +32,7 @@ path (relative paths are resolved from the repository root): go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` -The TS feature requests header codec processing with `encodeHeaders: true`. +The TS feature requests worker-side header codec processing with `codecHeaders: true`. SDKs without that option ignore it and fail the test. There is no test interceptor that decodes the header on the SDK's behalf. diff --git a/features/tracing/encoded_headers/feature.ts b/features/tracing/encoded_headers/feature.ts index 8def8141..9be1eea4 100644 --- a/features/tracing/encoded_headers/feature.ts +++ b/features/tracing/encoded_headers/feature.ts @@ -33,17 +33,18 @@ class WrappingCodec implements PayloadCodec { } // Keep the codec on the worker boundary; an interceptor workaround would mask the regression. -const dataConverter = { payloadCodecs: [new WrappingCodec()], encodeHeaders: true }; +const workerOptions = { + codecHeaders: true, + plugins: [ + new OpenTelemetryPlugin({ + resource: new Resource({ 'service.name': 'encoded-headers-feature' }), + spanProcessor: new SimpleSpanProcessor(new InMemorySpanExporter()), + }), + ], +}; export const feature = new Feature({ workflowsPath: require.resolve('./workflow'), - dataConverter, - workerOptions: { - plugins: [ - new OpenTelemetryPlugin({ - resource: new Resource({ 'service.name': 'encoded-headers-feature' }), - spanProcessor: new SimpleSpanProcessor(new InMemorySpanExporter()), - }), - ], - }, + dataConverter: { payloadCodecs: [new WrappingCodec()] }, + workerOptions, }); From ad1b0271bb0075fad82ad78f0a97cfc9d73b9c55 Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Fri, 30 Oct 2026 17:33:21 -0700 Subject: [PATCH 3/6] Expand encoded tracing header participants --- README.md | 12 +- build.gradle | 3 + cmd/run.go | 13 +- cmd/run_cross_language.go | 32 ++- cmd/run_go.go | 35 ++- cmd/run_java.go | 5 + cmd/run_ruby.go | 13 +- cmd/run_rust.go | 9 +- features/go.mod | 5 +- features/go.sum | 2 + features/tracing/encoded_headers/README.md | 104 ++++++--- .../tracing/encoded_headers/driver/main.go | 77 ++++++- .../encoded_headers/driver/main_test.go | 30 +++ features/tracing/encoded_headers/feature.cs | 44 +++- features/tracing/encoded_headers/feature.go | 141 ++++++++++++ features/tracing/encoded_headers/feature.java | 158 +++++++++++++ features/tracing/encoded_headers/feature.py | 101 +++++++++ features/tracing/encoded_headers/feature.rb | 79 +++++++ features/tracing/encoded_headers/feature.rs | 150 +++++++++++++ harness/go/cmd/run.go | 26 ++- harness/go/harness/runner.go | 14 +- .../java/io/temporal/sdkfeatures/Main.java | 27 ++- .../java/io/temporal/sdkfeatures/Runner.java | 14 +- harness/python/feature.py | 9 +- harness/python/main.py | 2 + harness/ruby/lib/harness.rb | 12 +- harness/ruby/runner.rb | 25 ++- harness/rust/Cargo.lock | 207 +++++++++++++++++- harness/rust/Cargo.toml | 9 + harness/rust/build.rs | 8 + harness/rust/src/harness.rs | 16 +- harness/rust/src/options.rs | 2 + pyproject.toml | 5 +- sdkbuild/java.go | 12 + sdkbuild/python.go | 12 +- sdkbuild/rust.go | 6 +- uv.lock | 47 +++- 37 files changed, 1357 insertions(+), 109 deletions(-) create mode 100644 features/tracing/encoded_headers/driver/main_test.go create mode 100644 features/tracing/encoded_headers/feature.go create mode 100644 features/tracing/encoded_headers/feature.java create mode 100644 features/tracing/encoded_headers/feature.py create mode 100644 features/tracing/encoded_headers/feature.rb create mode 100644 features/tracing/encoded_headers/feature.rs diff --git a/README.md b/README.md index d835cc86..b624aeb4 100644 --- a/README.md +++ b/README.md @@ -176,8 +176,16 @@ SDKs independently. For example: go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` -Only the .NET and TypeScript harnesses currently expose separate roles. Other -languages can be added as features require them. Cross-language features own their +Use repeated `--sdk-language` options to prepare only selected participants, without +imposing pair policy on the runner. For the focused original regression: + +```sh +go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +Go, Java, Python, Ruby, Rust, .NET and TypeScript harnesses expose separate roles. +See the feature's README for which roles its participants support and its +feature-specific scenario filters. Cross-language features own their history assertions and do not use the single-language history comparison/generation mechanism. This subcommand exposes SDK selection, server/namespace/TLS options, and temporary-build retention, but not history-generation or prepared-directory flags. diff --git a/build.gradle b/build.gradle index bfc4737f..7bc4ab86 100644 --- a/build.gradle +++ b/build.gradle @@ -33,6 +33,9 @@ dependencies { implementation 'com.jayway.jsonpath:json-path:2.6.0' implementation 'info.picocli:picocli:4.6.2' implementation 'io.temporal:temporal-sdk:latest.release' + implementation 'io.temporal:temporal-opentracing:latest.release' + implementation 'io.opentelemetry:opentelemetry-sdk:1.49.0' + implementation 'io.opentelemetry:opentelemetry-opentracing-shim:1.49.0' implementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' implementation 'org.reflections:reflections:0.10.2' } diff --git a/cmd/run.go b/cmd/run.go index 57cbeafc..c7c9dfe2 100644 --- a/cmd/run.go +++ b/cmd/run.go @@ -155,12 +155,13 @@ type Runner struct { log log.Logger config RunConfig // Root of the features repo - rootDir string - createTime time.Time - program sdkbuild.Program - crossPrograms map[string]sdkbuild.Program - crossLanguage bool - crossVersions map[string]string + rootDir string + createTime time.Time + program sdkbuild.Program + crossPrograms map[string]sdkbuild.Program + crossLanguage bool + crossVersions map[string]string + crossLanguages []string } type runBatch struct { diff --git a/cmd/run_cross_language.go b/cmd/run_cross_language.go index 4eb98d5d..0b4142cf 100644 --- a/cmd/run_cross_language.go +++ b/cmd/run_cross_language.go @@ -7,6 +7,7 @@ import ( "os" "os/exec" "path/filepath" + "slices" "strings" "time" @@ -18,7 +19,8 @@ import ( type CrossLanguageRunConfig struct { RunConfig - SDKVersions cli.StringSlice + SDKVersions cli.StringSlice + SDKLanguages cli.StringSlice } func runCrossLanguageCmd() *cli.Command { @@ -31,6 +33,10 @@ func runCrossLanguageCmd() *cli.Command { Name: "sdk-version", Destination: &config.SDKVersions, Usage: "SDK selection, e.g. cs=1.21.1 or ts=/path/to/sdk", }, + &cli.StringSliceFlag{ + Name: "sdk-language", Destination: &config.SDKLanguages, + Usage: "Prepare only these participants (repeatable; default: all discovered languages)", + }, &cli.BoolFlag{ Name: "retain-temp-dir", Destination: &config.RetainTempDir, Usage: "Do not delete temporary SDK and driver builds", @@ -43,6 +49,13 @@ func runCrossLanguageCmd() *cli.Command { } runner := NewRunner(config.RunConfig) runner.crossLanguage, runner.crossVersions = true, versions + for _, language := range config.SDKLanguages.Value() { + lang, err := normalizeLangName(language) + if err != nil { + return err + } + runner.crossLanguages = append(runner.crossLanguages, lang) + } features, err := runner.GlobCrossLanguageFeatures(ctx.Args().Slice()) if err != nil { return err @@ -112,6 +125,9 @@ func (r *Runner) runCrossLanguageFeature( if _, err := normalizeLangName(lang); err != nil { continue } + if len(r.crossLanguages) != 0 && !slices.Contains(r.crossLanguages, lang) { + continue + } program, err := r.crossLanguageProgram(ctx, lang, versions[lang]) if err != nil { return fmt.Errorf("prepare %s: %w", lang, err) @@ -128,6 +144,10 @@ func (r *Runner) runCrossLanguageFeature( } if lang == "ts" { args = append([]string{"./tslib/harness/ts/main.js"}, args...) + } else if lang == "go" { + args = append([]string{"run"}, args...) + } else if lang == "py" { + args = append([]string{"harness.python.main"}, args...) } command, err := program.NewCommand(ctx, args...) if err != nil { @@ -181,6 +201,16 @@ func (r *Runner) crossLanguageProgram(ctx context.Context, lang, version string) program, err = p.BuildDotNetProgram(ctx) case "ts": program, err = p.BuildTypeScriptProgram(ctx) + case "go": + program, err = p.BuildGoProgram(ctx) + case "py": + program, err = p.BuildPythonProgram(ctx) + case "java": + program, err = p.BuildJavaProgram(ctx, true) + case "rb": + program, err = p.BuildRubyProgram(ctx) + case "rs": + program, err = p.BuildRustProgram(ctx) default: return nil, fmt.Errorf("cross-language harness roles are not implemented for %s yet", lang) } diff --git a/cmd/run_go.go b/cmd/run_go.go index ee13c67c..c2e85529 100644 --- a/cmd/run_go.go +++ b/cmd/run_go.go @@ -3,6 +3,8 @@ package cmd import ( "context" "fmt" + "path/filepath" + "strings" "github.com/temporalio/features/harness/go/cmd" "github.com/temporalio/features/sdkbuild" @@ -13,7 +15,7 @@ import ( // root directory. func (p *Preparer) BuildGoProgram(ctx context.Context) (sdkbuild.Program, error) { p.log.Info("Building Go project", "DirName", p.config.DirName) - prog, err := sdkbuild.BuildGoProgram(ctx, sdkbuild.BuildGoProgramOptions{ + options := sdkbuild.BuildGoProgramOptions{ BaseDir: p.rootDir, DirName: p.config.DirName, Version: p.config.Version, @@ -39,7 +41,36 @@ func main() { cmd.Execute() }`, GoBuildTags: cmd.GoBuildTags(p.config.Version), - }) + } + if p.config.crossLanguage { + runner := NewRunner(RunConfig{}) + runner.rootDir = p.rootDir + features, err := runner.GlobCrossLanguageFeatures(nil) + if err != nil { + return nil, err + } + options.GoMainContents = `package main +import ( +"github.com/temporalio/features/harness/go/cmd" +"github.com/temporalio/features/harness/go/harness" +` + var registrations []string + for i, feature := range features { + if matches, _ := filepath.Glob(filepath.Join(p.rootDir, "features", feature.Dir, "feature.go")); len(matches) != 0 { + options.GoMainContents += fmt.Sprintf("f%d \"github.com/temporalio/features/features/%s\"\n", i, feature.Dir) + registrations = append(registrations, fmt.Sprintf("f%d.Feature", i)) + } + } + options.GoMainContents += ")\nfunc main() { harness.MustRegisterFeatures(" + strings.Join(registrations, ",") + "); cmd.Execute() }\n" + if strings.ContainsAny(p.config.Version, `/\`) { + sdkPath, err := filepath.Abs(p.config.Version) + if err != nil { + return nil, err + } + options.GoModContents += "\nreplace go.temporal.io/sdk/contrib/opentelemetry => " + filepath.ToSlash(filepath.Join(sdkPath, "contrib", "opentelemetry")) + "\n" + } + } + prog, err := sdkbuild.BuildGoProgram(ctx, options) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) } diff --git a/cmd/run_java.go b/cmd/run_java.go index af4e6b35..46fab07a 100644 --- a/cmd/run_java.go +++ b/cmd/run_java.go @@ -14,6 +14,10 @@ import ( // root directory. func (p *Preparer) BuildJavaProgram(ctx context.Context, build bool) (sdkbuild.Program, error) { p.log.Info("Building Java project", "DirName", p.config.DirName) + var modules []string + if p.config.crossLanguage { + modules = []string{"temporal-opentracing"} + } prog, err := sdkbuild.BuildJavaProgram(ctx, sdkbuild.BuildJavaProgramOptions{ BaseDir: p.rootDir, DirName: p.config.DirName, @@ -21,6 +25,7 @@ func (p *Preparer) BuildJavaProgram(ctx context.Context, build bool) (sdkbuild.P HarnessDependency: "io.temporal:features:0.1.0", MainClass: "io.temporal.sdkfeatures.Main", Build: build, + SDKModules: modules, }) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) diff --git a/cmd/run_ruby.go b/cmd/run_ruby.go index 99c2f2cf..ab070e67 100644 --- a/cmd/run_ruby.go +++ b/cmd/run_ruby.go @@ -41,11 +41,16 @@ func (p *Preparer) BuildRubyProgram(ctx context.Context) (sdkbuild.Program, erro } } + var dependencies []sdkbuild.RubyDependency + if p.config.crossLanguage { + dependencies = []sdkbuild.RubyDependency{{Name: "opentelemetry-sdk"}} + } prog, err := sdkbuild.BuildRubyProgram(ctx, sdkbuild.BuildRubyProgramOptions{ - BaseDir: p.rootDir, - SourceDir: rubyDir, - DirName: p.config.DirName, - Version: version, + BaseDir: p.rootDir, + SourceDir: rubyDir, + DirName: p.config.DirName, + Version: version, + MoreDependencies: dependencies, }) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) diff --git a/cmd/run_rust.go b/cmd/run_rust.go index 698dc78b..83547406 100644 --- a/cmd/run_rust.go +++ b/cmd/run_rust.go @@ -13,10 +13,11 @@ import ( func (p *Preparer) BuildRustProgram(ctx context.Context) (sdkbuild.Program, error) { p.log.Info("Building Rust project", "DirName", p.config.DirName) program, err := sdkbuild.BuildRustProgram(ctx, sdkbuild.BuildRustProgramOptions{ - BaseDir: p.rootDir, - DirName: p.config.DirName, - Version: p.config.Version, - PackageDir: filepath.Join(p.rootDir, "harness", "rust"), + BaseDir: p.rootDir, + DirName: p.config.DirName, + Version: p.config.Version, + PackageDir: filepath.Join(p.rootDir, "harness", "rust"), + CrossLanguage: p.config.crossLanguage, }) if err != nil { return nil, fmt.Errorf("failed preparing Rust: %w", err) diff --git a/features/go.mod b/features/go.mod index 6c2ea58e..047d176d 100644 --- a/features/go.mod +++ b/features/go.mod @@ -12,12 +12,15 @@ require ( github.com/temporalio/features/harness/go v0.0.0-00010101000000-000000000000 github.com/uber-go/tally/v4 v4.1.1 github.com/urfave/cli/v2 v2.3.0 + go.opentelemetry.io/otel v1.44.0 + go.opentelemetry.io/otel/sdk v1.44.0 go.temporal.io/api v1.63.5 go.temporal.io/sdk v1.49.0 go.temporal.io/sdk/contrib/aws/s3driver v0.1.1 go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2 v0.1.1 go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0 go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0 + go.temporal.io/sdk/contrib/opentelemetry v0.8.1 go.temporal.io/sdk/contrib/sysinfo v0.1.0 go.temporal.io/sdk/contrib/tally v0.2.0 golang.org/x/mod v0.38.0 @@ -97,9 +100,7 @@ require ( go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.62.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect go.opentelemetry.io/otel/trace v1.44.0 // indirect go.uber.org/atomic v1.9.0 // indirect diff --git a/features/go.sum b/features/go.sum index d05aa7a7..db5e8ecf 100644 --- a/features/go.sum +++ b/features/go.sum @@ -378,6 +378,8 @@ go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0 h1:pWclkV4CA6bAQ4gasJzIgNffJdRTb go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0/go.mod h1:4rjw/25qkAjku1odNdeVVyEyfczGPv132km2gEP4QKk= go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0 h1:mT0Cfqjr+pwbKMch60dVd2Fcidx6XXScF/eJSbfLy/w= go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0/go.mod h1:eg5XhF762ultvKxIaLxM8Bu22kEFg84bJev/0sXypm8= +go.temporal.io/sdk/contrib/opentelemetry v0.8.1 h1:wmQnxBWUsQQN6QihaEuUmsn8ZK6d+2G9oQF5bN4ObiY= +go.temporal.io/sdk/contrib/opentelemetry v0.8.1/go.mod h1:NnJgL/EwJIaWZVx4Vmb/qMh18a0fTu00VG/ojQ7tHPY= go.temporal.io/sdk/contrib/sysinfo v0.1.0 h1:jqP6BFZ/n+BoTt/OnlD+llufgSJSoxlq+aAIZCxnBdI= go.temporal.io/sdk/contrib/sysinfo v0.1.0/go.mod h1:1i61HTH1W1M331FprZF3SHeLFhZQSmb/YEbFsPhI654= go.temporal.io/sdk/contrib/tally v0.2.0 h1:XnTJIQcjOv+WuCJ1u8Ve2nq+s2H4i/fys34MnWDRrOo= diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md index e858a046..5190ab4e 100644 --- a/features/tracing/encoded_headers/README.md +++ b/features/tracing/encoded_headers/README.md @@ -1,46 +1,90 @@ # Encoded tracing headers across languages -Reproduces [.NET → TypeScript encoded tracing headers](https://github.com/temporalio/sdk-typescript/issues/514#issuecomment-6259375934). -A .NET client using its tracing interceptor and payload codec starts a workflow -on a TypeScript OpenTelemetry worker using the matching codec. +Exercises real SDK tracing integrations across workflow starts, including the +original [.NET → TypeScript regression](https://github.com/temporalio/sdk-typescript/issues/514#issuecomment-6259375934). +No interceptor decodes headers on an SDK's behalf. Every client checks that: -The driver currently runs only .NET → TypeScript. It requires the workflow to -complete without Workflow Task failures, round-trip its input/result, and retain -the caller's trace identity. It verifies that the history's `_tracer-data` header -was actually codec-encoded. Silently discarding an unreadable trace header is not -a pass. +- History contains a codec-encoded `_tracer-data` header with W3C `traceparent` + retaining the caller's trace identity. +- The workflow completes and round-trips its input and result through the codec. +- The real workflow tracing span retains that identity (silently dropping an + unreadable header is not a pass). +- No Workflow Task failed, even if a subsequent attempt succeeded. -Both codecs wrap serialized protobuf `Payload` bytes with XOR `0x5a`, setting -`encoding` to `binary/encrypted`. This is a test codec, **not encryption**. -Both reject double encoding. +All participants wrap the entire serialized protobuf `Payload` with XOR `0x5a` +and set `metadata.encoding=binary/encrypted`. This deterministic test codec is +**not encryption**. Every codec rejects double encoding. Raw client-supplied +Payloads are wire-ready; this feature does not install a converter-wide wrapper +or manually rewrite tracing headers. -From the repository root, with the usual Go, .NET, Node and Corepack/pnpm prerequisites: +## Participants + +| SDK | Encoded tracing client | Worker | Real integration/configuration | +| --- | --- | --- | --- | +| .NET (`cs`) | Yes | Yes | `TracingInterceptor`, configured client codec | +| Go (`go`) | Yes | Yes | OpenTelemetry interceptor with producer-specific `TracerOptions.EncodeHeaders: true`; client codec | +| Java (`java`) | Yes | Yes | OpenTracing interceptors with the OpenTelemetry shim/W3C propagator and producer-specific `setEncodeHeaders(true)`; client codec | +| Python (`py`) | Yes | Yes | `TracingInterceptor`, client `HeaderCodecBehavior.CODEC` and codec | +| Ruby (`rb`) | Yes | Yes | OpenTelemetry tracing interceptor and client codec; worker codec thread pool | +| Rust (`rs`) | No | Yes | Experimental OpenTelemetry worker plugin and existing activation codec traversal | +| TypeScript (`ts`) | No | Yes | OpenTelemetry plugin, worker `codecHeaders: true` and payload codecs | +| PHP (`php`) | No | No | No SDK tracing integration in the inspected checkout; no participant is fabricated | + +Rust's tracing client producer currently serializes an ordinary tracing carrier +without a producer-specific codec opt-in. It therefore cannot supply this +feature's encoded start header. Its worker already decodes activation headers +before tracing extraction and participates without SDK changes. The intentionally +closed Rust converter-wide encoding proposal is not needed or reinstated. +TypeScript's client tracing producer also emits a normally serialized carrier +and has no codec opt-in under the wire-ready client-header policy. It is therefore +unsupported as an encoded producer, not merely untested. The worker option +`codecHeaders` cannot enable client tracing production. +PHP would first need a real tracing integration and a codec/header policy. + +## Running + +By default, the runner discovers and prepares all participant files once. The +feature driver runs every supported client/worker pair among the prepared SDKs, +including same-language controls. Each pair gets its own queue and a 45-second +deadline; failures are labeled and aggregated while later pairs continue. Workers +are stopped and reaped on success, failure and cancellation. No tracing backend +is required. + +The original .NET → TypeScript case remains independently runnable: ```sh -go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=1.25.0 tracing/encoded_headers +go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` -This is a **failing regression test** with those releases: TypeScript raises -`Unknown encoding: binary/encrypted` in `extractContextFromHeaders`. It is not -marked as an expected failure. The workflow has a 15-second execution timeout; -the driver has a one-minute scenario deadline and prints the original task failure. +With `ts=1.25.0` this is a **failing regression test**, not an expected-failure +success: tracing extraction raises `Unknown encoding: binary/encrypted`. +The fixed TypeScript worker uses `codecHeaders`, not the removed data-converter +`encodeHeaders` flag. -To select SDK changes under development, replace either version with a checkout -path (relative paths are resolved from the repository root): +To validate the Go and Java producer opt-ins against branches under development: ```sh -go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +go run . run-cross-language --sdk-language go --sdk-language java --sdk-language py --sdk-version go=/path/to/sdk-go --sdk-version java=/path/to/sdk-java tracing/encoded_headers ``` -The TS feature requests worker-side header codec processing with `codecHeaders: true`. -SDKs without that option ignore it and fail the test. There is no test interceptor -that decodes the header on the SDK's behalf. +Local Go selection also substitutes its independently versioned OpenTelemetry +module; local Java selection substitutes its OpenTracing module. Older releases +without the opt-ins cannot run these producer participants and fail rather than +silently testing unencoded headers. SDKs must be fixed/merged before this feature +change lands. + +Use `ENCODED_HEADERS_PAIRS` only when focusing on particular scenarios: + +```sh +ENCODED_HEADERS_PAIRS=py:rs go run . run-cross-language --sdk-language py --sdk-language rs --sdk-version rs=/path/to/sdk-rust tracing/encoded_headers +``` -The runner reuses the normal SDK preparation and dev-server setup. The driver -launches the existing TS harness in worker-only mode and the .NET harness in -client-only mode. It stops the worker on success or failure. No external tracing -backend is used, and no C# source is embedded in the driver. +The filter is a comma-separated list of `client:worker` language codes. Requested +unsupported roles or unprepared participants are errors; they never disappear +from the run or count as passes. `--sdk-language` only limits preparation; all +pair/scenario policy stays in this feature's driver. Ruby preparation requires +the Ruby version specified by the harness gemspec; Rust requires the package's +pinned compiler/protoc and builds its `cross-language` Cargo feature. -Further languages and scenarios belong in this feature's driver and participants, -not in a Cartesian-product policy in the runner. Single-language history replay -is not applicable here; the .NET participant checks the actual TS execution history. +Single-language history comparison/replay is intentionally not used: the client +participant checks the actual other-language workflow history. diff --git a/features/tracing/encoded_headers/driver/main.go b/features/tracing/encoded_headers/driver/main.go index b194d80d..3f277e6d 100644 --- a/features/tracing/encoded_headers/driver/main.go +++ b/features/tracing/encoded_headers/driver/main.go @@ -2,9 +2,12 @@ package main import ( "context" + "errors" "fmt" "os" "os/signal" + "slices" + "strings" "time" "github.com/temporalio/features/harness/go/crosslanguage" @@ -20,18 +23,80 @@ func main() { func run() error { ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) defer cancel() - ctx, timeout := context.WithTimeout(ctx, time.Minute) - defer timeout() participants, err := crosslanguage.FromEnv() if err != nil { return err } - queue := participants.TaskQueue + "-cs-ts" - stop, err := participants.StartWorker(ctx, "ts", queue) + pairs, err := selectPairs(participants, os.Getenv("ENCODED_HEADERS_PAIRS")) + if err != nil { + return err + } + var failures []error + for _, pair := range pairs { + if ctx.Err() != nil { + return errors.Join(append(failures, ctx.Err())...) + } + fmt.Printf("Testing encoded tracing headers: %s client → %s worker\n", pair[0], pair[1]) + err := runPair(ctx, participants, pair) + if err != nil { + err = fmt.Errorf("%s → %s: %w", pair[0], pair[1], err) + fmt.Fprintln(os.Stderr, err) + failures = append(failures, err) + } else { + fmt.Printf("PASS %s → %s\n", pair[0], pair[1]) + } + } + return errors.Join(failures...) +} + +var clients = []string{"cs", "go", "java", "py", "rb"} +var workers = []string{"cs", "go", "java", "py", "rb", "rs", "ts"} + +func selectPairs(manifest *crosslanguage.Manifest, filter string) ([][2]string, error) { + var pairs [][2]string + if filter != "" { + for _, selection := range strings.Split(filter, ",") { + client, worker, ok := strings.Cut(selection, ":") + if !ok || !slices.Contains(clients, client) || !slices.Contains(workers, worker) { + return nil, fmt.Errorf("invalid ENCODED_HEADERS_PAIRS pair %q: clients=%v workers=%v; PHP has no tracing integration; Rust/TS have no encoded tracing producer opt-in", selection, clients, workers) + } + if _, ok := manifest.Programs[client]; !ok { + return nil, fmt.Errorf("client %s is not prepared; include --sdk-language %s", client, client) + } + if _, ok := manifest.Programs[worker]; !ok { + return nil, fmt.Errorf("worker %s is not prepared; include --sdk-language %s", worker, worker) + } + pair := [2]string{client, worker} + if !slices.Contains(pairs, pair) { + pairs = append(pairs, pair) + } + } + } else { + for _, client := range clients { + if _, ok := manifest.Programs[client]; !ok { + continue + } + for _, worker := range workers { + if _, ok := manifest.Programs[worker]; ok { + pairs = append(pairs, [2]string{client, worker}) + } + } + } + } + if len(pairs) == 0 { + return nil, fmt.Errorf("no supported client/worker pairs among prepared participants") + } + return pairs, nil +} + +func runPair(ctx context.Context, participants *crosslanguage.Manifest, pair [2]string) error { + ctx, cancel := context.WithTimeout(ctx, 45*time.Second) + defer cancel() + queue := participants.TaskQueue + "-" + pair[0] + "-" + pair[1] + stop, err := participants.StartWorker(ctx, pair[1], queue) if err != nil { return err } defer stop() - fmt.Println("Testing encoded tracing headers: .NET client → TypeScript worker") - return participants.RunClient(ctx, "cs", queue) + return participants.RunClient(ctx, pair[0], queue) } diff --git a/features/tracing/encoded_headers/driver/main_test.go b/features/tracing/encoded_headers/driver/main_test.go new file mode 100644 index 00000000..9d66b12c --- /dev/null +++ b/features/tracing/encoded_headers/driver/main_test.go @@ -0,0 +1,30 @@ +package main + +import ( + "strings" + "testing" + + "github.com/temporalio/features/harness/go/crosslanguage" +) + +func TestPairSelection(t *testing.T) { + manifest := &crosslanguage.Manifest{Programs: map[string]crosslanguage.Program{ + "cs": {}, "ts": {}, "go": {}, + }} + pairs, err := selectPairs(manifest, "") + if err != nil || len(pairs) != 6 { + t.Fatalf("expected cs/go clients × cs/go/ts workers: %v %v", pairs, err) + } + pairs, err = selectPairs(manifest, "cs:ts,cs:ts") + if err != nil || len(pairs) != 1 || pairs[0] != [2]string{"cs", "ts"} { + t.Fatalf("unexpected focused selection: %v %v", pairs, err) + } + for filter, message := range map[string]string{ + "go:java": "not prepared", "rs:ts": "no encoded tracing producer", + "cs:php": "no tracing integration", + } { + if _, err := selectPairs(manifest, filter); err == nil || !strings.Contains(err.Error(), message) { + t.Fatalf("%s: expected %q, got %v", filter, message, err) + } + } +} diff --git a/features/tracing/encoded_headers/feature.cs b/features/tracing/encoded_headers/feature.cs index c4ecfe18..54976970 100644 --- a/features/tracing/encoded_headers/feature.cs +++ b/features/tracing/encoded_headers/feature.cs @@ -10,9 +10,25 @@ namespace tracing.encoded_headers; using Temporalio.Extensions.OpenTelemetry; using Temporalio.Features.Harness; using Temporalio.Worker; +using Temporalio.Workflows; public class Feature : IFeature { + private static readonly ActivityListener Listener; + + static Feature() + { + var clientSourceName = TracingInterceptor.ClientSource.Name; + var workflowSourceName = TracingInterceptor.WorkflowsSource.Name; + Listener = new() + { + ShouldListenTo = source => source.Name == "header-codec-feature" || + source.Name == clientSourceName || source.Name == workflowSourceName, + Sample = (ref ActivityCreationOptions _) => ActivitySamplingResult.AllDataAndRecorded, + }; + ActivitySource.AddActivityListener(Listener); + } + public void ConfigureClient(Runner runner, TemporalClientConnectOptions options) { options.DataConverter = DataConverter.Default with { PayloadCodec = new WrappingCodec() }; @@ -22,18 +38,11 @@ public void ConfigureClient(Runner runner, TemporalClientConnectOptions options) }; } - public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) { } + public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) => + options.AddWorkflow(); public async Task ExecuteAsync(Runner runner) { - var clientSourceName = TracingInterceptor.ClientSource.Name; - using var listener = new ActivityListener - { - ShouldListenTo = source => source.Name == "header-codec-feature" || - source.Name == clientSourceName, - Sample = (ref ActivityCreationOptions _) => ActivitySamplingResult.AllDataAndRecorded, - }; - ActivitySource.AddActivityListener(listener); using var source = new ActivitySource("header-codec-feature"); using var parent = source.StartActivity("dotnet-caller")!; var options = runner.NewWorkflowOptions(); @@ -69,6 +78,23 @@ public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) { } } } + [Workflow("workflow")] + public class WorkflowImpl + { + [WorkflowRun] + public Task> RunAsync(string message) + { + var activity = WorkflowDiagnosticActivity.Current ?? + throw new InvalidOperationException("No active workflow tracing span"); + Assert.NotEqual(default, activity.Context.TraceId); + return Task.FromResult(new Dictionary + { + ["message"] = message, + ["traceId"] = activity.Context.TraceId.ToHexString(), + }); + } + } + sealed class WrappingCodec : IPayloadCodec { public const string EncodingName = "binary/encrypted"; diff --git a/features/tracing/encoded_headers/feature.go b/features/tracing/encoded_headers/feature.go new file mode 100644 index 00000000..feb7527a --- /dev/null +++ b/features/tracing/encoded_headers/feature.go @@ -0,0 +1,141 @@ +package encoded_headers + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + "github.com/temporalio/features/harness/go/harness" + "go.opentelemetry.io/otel/propagation" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + commonpb "go.temporal.io/api/common/v1" + enumspb "go.temporal.io/api/enums/v1" + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/contrib/opentelemetry" + "go.temporal.io/sdk/converter" + "go.temporal.io/sdk/interceptor" + "go.temporal.io/sdk/workflow" + "google.golang.org/protobuf/proto" +) + +const encoding = "binary/encrypted" + +type wrappingCodec struct{} + +func (wrappingCodec) Encode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) { + result := make([]*commonpb.Payload, len(payloads)) + for i, payload := range payloads { + if string(payload.Metadata["encoding"]) == encoding { + return nil, fmt.Errorf("payload encoded twice") + } + data, err := proto.Marshal(payload) + if err != nil { + return nil, err + } + for j := range data { + data[j] ^= 0x5a + } + result[i] = &commonpb.Payload{Metadata: map[string][]byte{"encoding": []byte(encoding)}, Data: data} + } + return result, nil +} + +func (wrappingCodec) Decode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) { + result := make([]*commonpb.Payload, len(payloads)) + for i, payload := range payloads { + if string(payload.Metadata["encoding"]) != encoding { + return nil, fmt.Errorf("expected encoded payload, got %q", payload.Metadata["encoding"]) + } + data := append([]byte(nil), payload.Data...) + for j := range data { + data[j] ^= 0x5a + } + result[i] = new(commonpb.Payload) + if err := proto.Unmarshal(data, result[i]); err != nil { + return nil, err + } + } + return result, nil +} + +var provider = sdktrace.NewTracerProvider() +var tracer = provider.Tracer("encoded-headers-feature") + +var Feature = harness.Feature{ + Workflows: harness.WorkflowWithOptions{Workflow: Workflow, Options: workflow.RegisterOptions{Name: "workflow"}}, + ClientOptions: client.Options{ + DataConverter: converter.NewCodecDataConverter(converter.GetDefaultDataConverter(), wrappingCodec{}), + Interceptors: []interceptor.ClientInterceptor{newTracingInterceptor()}, + }, + Execute: execute, +} + +func newTracingInterceptor() interceptor.Interceptor { + tracing, err := opentelemetry.NewTracingInterceptor(opentelemetry.TracerOptions{ + Tracer: tracer, EncodeHeaders: true, TextMapPropagator: propagation.TraceContext{}, + }) + if err != nil { + panic(err) + } + return tracing +} + +func Workflow(ctx workflow.Context, message string) (map[string]string, error) { + span, ok := opentelemetry.SpanFromWorkflowContext(ctx) + if !ok || !span.SpanContext().IsValid() { + return nil, fmt.Errorf("no active workflow tracing span") + } + return map[string]string{"message": message, "traceId": span.SpanContext().TraceID().String()}, nil +} + +func execute(ctx context.Context, r *harness.Runner) (client.WorkflowRun, error) { + ctx, parent := tracer.Start(ctx, "go-caller") + defer parent.End() + run, err := r.Client.ExecuteWorkflow(ctx, client.StartWorkflowOptions{ + TaskQueue: r.TaskQueue, WorkflowExecutionTimeout: 15 * time.Second, + }, "workflow", "hello") + if err != nil { + return nil, err + } + var result map[string]string + resultErr := run.Get(ctx, &result) + history := r.Client.GetWorkflowHistory(ctx, run.GetID(), run.GetRunID(), false, enumspb.HISTORY_EVENT_FILTER_TYPE_ALL_EVENT) + found := false + for history.HasNext() { + event, err := history.Next() + if err != nil { + return nil, err + } + if failed := event.GetWorkflowTaskFailedEventAttributes(); failed != nil { + return nil, fmt.Errorf("workflow task failed: %v", failed.Failure) + } + if started := event.GetWorkflowExecutionStartedEventAttributes(); started != nil { + header := started.Header.GetFields()["_tracer-data"] + if header == nil { + return nil, fmt.Errorf("missing tracing header") + } + decoded, err := (wrappingCodec{}).Decode([]*commonpb.Payload{header}) + if err != nil { + return nil, err + } + var carrier map[string]string + if err := json.Unmarshal(decoded[0].Data, &carrier); err != nil { + return nil, err + } + parts := strings.Split(carrier["traceparent"], "-") + if len(parts) != 4 || parts[1] != parent.SpanContext().TraceID().String() { + return nil, fmt.Errorf("history traceparent mismatch: %v", carrier) + } + found = true + } + } + if resultErr != nil { + return nil, resultErr + } + if !found || result["message"] != "hello" || result["traceId"] != parent.SpanContext().TraceID().String() { + return nil, fmt.Errorf("trace identity/input round-trip failed: history=%t result=%v", found, result) + } + return nil, nil +} diff --git a/features/tracing/encoded_headers/feature.java b/features/tracing/encoded_headers/feature.java new file mode 100644 index 00000000..66675856 --- /dev/null +++ b/features/tracing/encoded_headers/feature.java @@ -0,0 +1,158 @@ +package tracing.encoded_headers; + +import static org.junit.jupiter.api.Assertions.*; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.protobuf.ByteString; +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Scope; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.opentracingshim.OpenTracingShim; +import io.opentelemetry.sdk.OpenTelemetrySdk; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.temporal.api.common.v1.Payload; +import io.temporal.client.WorkflowClientOptions; +import io.temporal.common.converter.CodecDataConverter; +import io.temporal.common.converter.DefaultDataConverter; +import io.temporal.opentracing.OpenTracingClientInterceptor; +import io.temporal.opentracing.OpenTracingOptions; +import io.temporal.opentracing.OpenTracingWorkerInterceptor; +import io.temporal.payload.codec.PayloadCodec; +import io.temporal.sdkfeatures.Feature; +import io.temporal.sdkfeatures.Run; +import io.temporal.sdkfeatures.Runner; +import io.temporal.worker.WorkerFactoryOptions; +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; +import java.util.*; + +@WorkflowInterface +public interface feature extends Feature { + @WorkflowMethod(name = "workflow") + Map workflow(String message); + + class Impl implements feature { + static final OpenTelemetry telemetry = + OpenTelemetrySdk.builder() + .setTracerProvider(SdkTracerProvider.builder().build()) + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .build(); + static final io.opentracing.Tracer tracer = OpenTracingShim.createTracerShim(telemetry); + final OpenTracingOptions options = tracingOptions(); + + static OpenTracingOptions tracingOptions() { + var builder = OpenTracingOptions.newBuilder().setTracer(tracer); + try { + // Older releases can still compile the ordinary suite; a selected participant must opt in. + builder.getClass().getMethod("setEncodeHeaders", boolean.class).invoke(builder, true); + } catch (ReflectiveOperationException e) { + throw new IllegalStateException( + "Java tracing requires producer-specific setEncodeHeaders(true)", e); + } + return builder.build(); + } + + @Override + public void workflowClientOptions(WorkflowClientOptions.Builder builder) { + builder.setDataConverter( + new CodecDataConverter( + DefaultDataConverter.newDefaultInstance(), List.of(new WrappingCodec()))); + builder.setInterceptors(new OpenTracingClientInterceptor(options)); + } + + @Override + public void workerFactoryOptions(WorkerFactoryOptions.Builder builder) { + builder.setWorkerInterceptors(new OpenTracingWorkerInterceptor(options)); + } + + @Override + public Map workflow(String message) { + var span = Span.current().getSpanContext(); + assertTrue(span.isValid(), "No active workflow tracing span"); + return Map.of("message", message, "traceId", span.getTraceId()); + } + + @Override + public Run execute(Runner runner) throws Exception { + var parent = + telemetry.getTracer("encoded-headers-feature").spanBuilder("java-caller").startSpan(); + try (Scope ignored = parent.makeCurrent()) { + var run = + runner.executeSingleWorkflow( + io.temporal.client.WorkflowOptions.newBuilder() + .setTaskQueue(runner.config.taskQueue) + .setWorkflowExecutionTimeout(java.time.Duration.ofSeconds(15)) + .build(), + "hello"); + Map result; + try { + result = runner.waitForRunResult(run, Map.class); + } finally { + for (var event : runner.getWorkflowHistory(run).getEventsList()) { + assertFalse(event.hasWorkflowTaskFailedEventAttributes(), event.toString()); + } + } + var header = + runner + .getWorkflowHistory(run) + .getEvents(0) + .getWorkflowExecutionStartedEventAttributes() + .getHeader() + .getFieldsOrThrow("_tracer-data"); + var decoded = new WrappingCodec().decode(List.of(header)).get(0); + Map carrier = + new ObjectMapper() + .readValue( + decoded.getData().toByteArray(), new TypeReference>() {}); + assertEquals( + parent.getSpanContext().getTraceId(), carrier.get("traceparent").split("-")[1]); + assertEquals( + Map.of("message", "hello", "traceId", parent.getSpanContext().getTraceId()), result); + return null; + } finally { + parent.end(); + } + } + } + + class WrappingCodec implements PayloadCodec { + static final ByteString ENCODING = ByteString.copyFromUtf8("binary/encrypted"); + + static byte[] xor(byte[] data) { + for (int i = 0; i < data.length; i++) data[i] ^= 0x5a; + return data; + } + + @Override + public List encode(List payloads) { + var result = new ArrayList(); + for (var payload : payloads) { + assertNotEquals( + ENCODING, payload.getMetadataMap().get("encoding"), "Payload encoded twice"); + result.add( + Payload.newBuilder() + .putMetadata("encoding", ENCODING) + .setData(ByteString.copyFrom(xor(payload.toByteArray()))) + .build()); + } + return result; + } + + @Override + public List decode(List payloads) { + var result = new ArrayList(); + for (var payload : payloads) { + assertEquals(ENCODING, payload.getMetadataMap().get("encoding")); + try { + result.add(Payload.parseFrom(xor(payload.getData().toByteArray()))); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw new IllegalArgumentException("Invalid wrapped payload", e); + } + } + return result; + } + } +} diff --git a/features/tracing/encoded_headers/feature.py b/features/tracing/encoded_headers/feature.py new file mode 100644 index 00000000..1b11481e --- /dev/null +++ b/features/tracing/encoded_headers/feature.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import dataclasses +import json +import uuid +from datetime import timedelta +from typing import Sequence + +from temporalio import workflow + +with workflow.unsafe.imports_passed_through(): + from opentelemetry import trace + from opentelemetry.propagate import set_global_textmap + from opentelemetry.sdk.trace import TracerProvider + from opentelemetry.trace.propagation.tracecontext import ( + TraceContextTextMapPropagator, + ) + from temporalio.api.common.v1 import Payload + from temporalio.common import HeaderCodecBehavior + from temporalio.contrib.opentelemetry import TracingInterceptor + from temporalio.converter import DataConverter, PayloadCodec + + from harness.python.feature import Runner, register_feature + + +class WrappingCodec(PayloadCodec): + async def encode(self, payloads: Sequence[Payload]) -> list[Payload]: + result = [] + for payload in payloads: + assert payload.metadata["encoding"] != b"binary/encrypted", ( + "Payload encoded twice" + ) + result.append( + Payload( + metadata={"encoding": b"binary/encrypted"}, + data=bytes(b ^ 0x5A for b in payload.SerializeToString()), + ) + ) + return result + + async def decode(self, payloads: Sequence[Payload]) -> list[Payload]: + result = [] + for payload in payloads: + assert payload.metadata["encoding"] == b"binary/encrypted" + result.append(Payload.FromString(bytes(b ^ 0x5A for b in payload.data))) + return result + + +@workflow.defn(name="workflow") +class Workflow: + @workflow.run + async def run(self, message: str) -> dict[str, str]: + span = trace.get_current_span().get_span_context() + assert span.is_valid, "No active workflow tracing span" + return {"message": message, "traceId": f"{span.trace_id:032x}"} + + +async def start(runner: Runner): + with trace.get_tracer("encoded-headers-feature").start_as_current_span( + "python-caller" + ) as parent: + trace_id = f"{parent.get_span_context().trace_id:032x}" + handle = await runner.client.start_workflow( + "workflow", + "hello", + id=str(uuid.uuid4()), + task_queue=runner.task_queue, + execution_timeout=timedelta(seconds=15), + ) + try: + result = await handle.result() + finally: + history = await handle.fetch_history() + for event in history.events: + assert not event.HasField("workflow_task_failed_event_attributes"), ( + event + ) + header = history.events[ + 0 + ].workflow_execution_started_event_attributes.header.fields["_tracer-data"] + decoded = (await WrappingCodec().decode([header]))[0] + carrier = json.loads(decoded.data) + assert carrier["traceparent"].split("-")[1] == trace_id + assert result == {"message": "hello", "traceId": trace_id}, result + return handle + + +if not workflow.unsafe.in_sandbox(): + trace.set_tracer_provider(TracerProvider()) + set_global_textmap(TraceContextTextMapPropagator()) + register_feature( + workflows=[Workflow], + start=start, + data_converter=dataclasses.replace( + DataConverter.default, payload_codec=WrappingCodec() + ), + additional_client_config={ + "interceptors": [TracingInterceptor()], + "header_codec_behavior": HeaderCodecBehavior.CODEC, + }, + ) diff --git a/features/tracing/encoded_headers/feature.rb b/features/tracing/encoded_headers/feature.rb new file mode 100644 index 00000000..0ff6c0d5 --- /dev/null +++ b/features/tracing/encoded_headers/feature.rb @@ -0,0 +1,79 @@ +# frozen_string_literal: true + +require 'json' +require 'securerandom' +require 'opentelemetry/sdk' +require 'temporalio/contrib/open_telemetry' +require 'temporalio/converters/data_converter' +require 'temporalio/converters/payload_codec' +require 'temporalio/workflow' + +module EncodedHeaders + class WrappingCodec < Temporalio::Converters::PayloadCodec + def encode(payloads) + payloads.map do |payload| + raise 'Payload encoded twice' if payload.metadata['encoding'] == 'binary/encrypted' + + Temporalio::Api::Common::V1::Payload.new( + metadata: { 'encoding' => 'binary/encrypted' }, + data: Temporalio::Api::Common::V1::Payload.encode(payload).bytes.map { |b| b ^ 0x5a }.pack('C*') + ) + end + end + + def decode(payloads) + payloads.map do |payload| + raise 'Expected encoded payload' unless payload.metadata['encoding'] == 'binary/encrypted' + + Temporalio::Api::Common::V1::Payload.decode(payload.data.bytes.map { |b| b ^ 0x5a }.pack('C*')) + end + end + end + + class Workflow < Temporalio::Workflow::Definition + workflow_name 'workflow' + + def execute(message) + span = Temporalio::Contrib::OpenTelemetry::Workflow.completed_span('feature-result') + raise 'No active workflow tracing span' unless span&.context&.valid? + + { 'message' => message, 'traceId' => span.context.hex_trace_id } + end + end + + PROVIDER = OpenTelemetry::SDK::Trace::TracerProvider.new + TRACER = PROVIDER.tracer('encoded-headers-feature') + + def self.start(client, task_queue, _feature) + TRACER.in_span('ruby-caller') do |parent| + trace_id = parent.context.hex_trace_id + handle = client.start_workflow( + 'workflow', 'hello', id: SecureRandom.uuid, task_queue: task_queue, execution_timeout: 15 + ) + begin + result = handle.result + ensure + history = handle.fetch_history + history.events.each do |event| + raise "Workflow task failed: #{event.workflow_task_failed_event_attributes}" if event.workflow_task_failed_event_attributes + end + end + header = history.events.first.workflow_execution_started_event_attributes.header.fields['_tracer-data'] + carrier = JSON.parse(WrappingCodec.new.decode([header]).first.data) + raise "History trace identity mismatch: #{carrier}" unless carrier['traceparent'].split('-')[1] == trace_id + raise "Input/trace round-trip mismatch: #{result}" unless result == { 'message' => 'hello', 'traceId' => trace_id } + + handle + end + end +end + +Harness.register_feature( + workflows: [EncodedHeaders::Workflow], + start: EncodedHeaders.method(:start), + worker_options: { workflow_payload_codec_thread_pool: Temporalio::Worker::ThreadPool.default }, + client_options: { + data_converter: Temporalio::Converters::DataConverter.new(payload_codec: EncodedHeaders::WrappingCodec.new), + interceptors: [Temporalio::Contrib::OpenTelemetry::TracingInterceptor.new(EncodedHeaders::TRACER)] + } +) diff --git a/features/tracing/encoded_headers/feature.rs b/features/tracing/encoded_headers/feature.rs new file mode 100644 index 00000000..129ba2d3 --- /dev/null +++ b/features/tracing/encoded_headers/feature.rs @@ -0,0 +1,150 @@ +use crate::harness::{Feature, FeatureContext, FeatureFuture}; +use anyhow::{Result, bail}; +use futures::{FutureExt, future::BoxFuture}; +use opentelemetry::{ + Context, + trace::{TraceContextExt, TracerProvider}, +}; +use prost::Message; +use std::collections::HashMap; +use temporalio_client::{Client, ClientOptions}; +use temporalio_common::{ + data_converters::{ + DataConverter, DefaultFailureConverter, PayloadCodec, PayloadConversionError, + PayloadConverter, SerializationContextData, + }, + protos::temporal::api::common::v1::Payload, +}; +use temporalio_macros::{workflow, workflow_methods}; +use temporalio_sdk::{ + WorkerOptions, WorkflowContext, WorkflowResult, opentelemetry::OpenTelemetryPlugin, +}; + +const ENCODING: &[u8] = b"binary/encrypted"; + +#[derive(Debug)] +struct WrappingCodec; + +impl PayloadCodec for WrappingCodec { + fn encode( + &self, + _: &SerializationContextData, + payloads: Vec, + ) -> BoxFuture<'static, Result, PayloadConversionError>> { + async move { + payloads + .into_iter() + .map(|payload| { + if payload.metadata.get("encoding").map(Vec::as_slice) == Some(ENCODING) { + return Err(PayloadConversionError::EncodingError( + "Payload encoded twice".into(), + )); + } + Ok(Payload { + metadata: HashMap::from([("encoding".to_owned(), ENCODING.to_vec())]), + data: payload + .encode_to_vec() + .into_iter() + .map(|b| b ^ 0x5a) + .collect(), + ..Default::default() + }) + }) + .collect() + } + .boxed() + } + + fn decode( + &self, + _: &SerializationContextData, + payloads: Vec, + ) -> BoxFuture<'static, Result, PayloadConversionError>> { + async move { + payloads + .into_iter() + .map(|payload| { + if payload.metadata.get("encoding").map(Vec::as_slice) != Some(ENCODING) { + return Err(PayloadConversionError::EncodingError( + "Expected encoded payload".into(), + )); + } + let data: Vec = payload.data.into_iter().map(|b| b ^ 0x5a).collect(); + Payload::decode(data.as_slice()) + .map_err(|e| PayloadConversionError::EncodingError(e.into())) + }) + .collect() + } + .boxed() + } +} + +#[workflow] +#[derive(Default)] +pub struct Workflow; + +#[workflow_methods] +impl Workflow { + #[run(name = "workflow")] + pub async fn run( + _ctx: &mut WorkflowContext, + message: String, + ) -> WorkflowResult> { + let context = Context::current(); + let span = context.span(); + assert!( + span.span_context().is_valid(), + "No active workflow tracing span" + ); + Ok(HashMap::from([ + ("message".to_owned(), message), + ( + "traceId".to_owned(), + span.span_context().trace_id().to_string(), + ), + ])) + } +} + +struct EncodedHeaders { + provider: opentelemetry_sdk::trace::SdkTracerProvider, +} + +impl Feature for EncodedHeaders { + fn configure_client(&self, client: Client) -> Result { + let options = ClientOptions::new(client.options().namespace.clone()) + .data_converter(DataConverter::new( + PayloadConverter::default(), + DefaultFailureConverter::default(), + WrappingCodec, + )) + .build(); + Ok(Client::new(client.connection().clone(), options)?) + } + + fn worker_options(&self, ctx: &FeatureContext) -> Result> { + Ok(Some( + WorkerOptions::new(ctx.task_queue.clone()) + .worker_plugin( + OpenTelemetryPlugin::builder() + .tracer(self.provider.tracer("encoded-headers-feature")) + .build(), + ) + .register_workflow::()? + .build(), + )) + } + + fn execute<'a>(&'a self, _: &'a FeatureContext) -> FeatureFuture<'a> { + Box::pin(async { + bail!("Rust is worker-only: the client tracing producer has no codec opt-in") + }) + } +} + +pub fn feature() -> Box { + let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder() + .with_id_generator(temporalio_sdk::opentelemetry::WorkflowIdGenerator::default()) + .build(); + Box::new(EncodedHeaders { provider }) +} diff --git a/harness/go/cmd/run.go b/harness/go/cmd/run.go index 5c0b6923..0d9a75b5 100644 --- a/harness/go/cmd/run.go +++ b/harness/go/cmd/run.go @@ -31,6 +31,9 @@ func runCmd() *cli.Command { Usage: "run a test or set of tests for Go", Flags: config.flags(), Action: func(ctx *cli.Context) error { + if config.Role != "" && config.Role != "client" && config.Role != "worker" { + return fmt.Errorf("role must be client or worker") + } var run Run if err := run.FromArgs(ctx.Args().Slice()); err != nil { return err @@ -131,6 +134,7 @@ type RunFeatureConfigGo struct { // RunConfig is configuration for NewRunner. type RunConfig struct { + Role string Server string Namespace string ClientCertPath string @@ -143,6 +147,9 @@ type RunConfig struct { func (r *RunConfig) flags() []cli.Flag { return []cli.Flag{ + &cli.StringFlag{ + Name: "role", Destination: &r.Role, + }, &cli.StringFlag{ Name: "server", Usage: "The host:port of the server (default is to create ephemeral in-memory server)", @@ -228,11 +235,15 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { if len(run.Features) == 0 { return fmt.Errorf("no features to run") } - summary, err := openSummary(r.config.SummaryURI) - if err != nil { - return err + var summary io.WriteCloser + if r.config.Role == "" { + var err error + summary, err = openSummary(r.config.SummaryURI) + if err != nil { + return err + } + defer summary.Close() } - defer summary.Close() var failureCount int failureSummary := "" allFeatures := harness.RegisteredFeatures() @@ -258,8 +269,10 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { Outcome: FeaturePassed, } defer func() { - bytes, _ := json.Marshal(sumEntry) - fmt.Fprintln(summary, string(bytes)) + if summary != nil { + bytes, _ := json.Marshal(sumEntry) + fmt.Fprintln(summary, string(bytes)) + } }() if feature.SkipReason != "" { @@ -274,6 +287,7 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { } runnerConfig := harness.RunnerConfig{ + Role: r.config.Role, ServerHostPort: r.config.Server, Namespace: r.config.Namespace, ClientCertPath: r.config.ClientCertPath, diff --git a/harness/go/harness/runner.go b/harness/go/harness/runner.go index 83eb4f68..19282f5d 100644 --- a/harness/go/harness/runner.go +++ b/harness/go/harness/runner.go @@ -49,6 +49,7 @@ type Runner struct { // RunnerConfig is configuration for NewRunner. type RunnerConfig struct { + Role string ServerHostPort string Namespace string TaskQueue string @@ -110,9 +111,10 @@ func NewRunner(config RunnerConfig, feature *PreparedFeature) (*Runner, error) { if !r.Feature.DisableWorkflowPanicPolicyOverride { r.Feature.WorkerOptions.WorkflowPanicPolicy = worker.FailWorkflow } - err = r.StartWorker() - if err != nil { - return nil, err + if config.Role != "client" { + if err = r.StartWorker(); err != nil { + return nil, err + } } success = true @@ -123,6 +125,12 @@ func NewRunner(config RunnerConfig, feature *PreparedFeature) (*Runner, error) { func (r *Runner) Run(ctx context.Context) error { defer r.Close() + if r.Role == "worker" { + fmt.Println("FEATURE_WORKER_READY") + <-ctx.Done() + return ctx.Err() + } + // Do normal run r.Log.Debug("Executing feature", "Feature", r.Feature.Dir) var run client.WorkflowRun diff --git a/harness/java/io/temporal/sdkfeatures/Main.java b/harness/java/io/temporal/sdkfeatures/Main.java index f7ff70e3..4f5dba9e 100644 --- a/harness/java/io/temporal/sdkfeatures/Main.java +++ b/harness/java/io/temporal/sdkfeatures/Main.java @@ -75,9 +75,12 @@ BufferedWriter createSummaryServerWriter() { private static final Logger log = LoggerFactory.getLogger(Main.class); - @Option(names = "--summary-uri", description = "The URL of the summary server", required = true) + @Option(names = "--summary-uri", description = "The URL of the summary server") private String summaryUri; + @Option(names = "--role", description = "Cross-language harness role") + private String role; + @Option(names = "--server", description = "The host:port of the server", required = true) private String server; @@ -104,6 +107,12 @@ BufferedWriter createSummaryServerWriter() { @Override public void run() { + if (role != null && !role.equals("client") && !role.equals("worker")) { + throw new IllegalArgumentException("role must be client or worker"); + } + if (role == null && summaryUri == null) { + throw new IllegalArgumentException("Missing --summary-uri"); + } // Load TLS certs if specified SslContext sslContext = null; if (StringUtils.isNotEmpty(clientCertPath)) { @@ -146,7 +155,8 @@ public void run() { throw new RuntimeException("Client cert path must be specified since key path is"); } - try (BufferedWriter writer = createSummaryServerWriter()) { + try (BufferedWriter writer = + role == null ? createSummaryServerWriter() : new BufferedWriter(Writer.nullWriter())) { ObjectMapper mapper = new ObjectMapper(); // Run each @@ -157,7 +167,7 @@ public void run() { var pieces = featureWithTaskQueue.split(":", 3); // Find feature var feature = - Arrays.stream(PreparedFeature.ALL) + Arrays.stream(role == null ? PreparedFeature.ALL : crossLanguageFeature(pieces[0])) .filter(p -> p.dir.equals(pieces[0])) .findAny() .orElseThrow( @@ -175,6 +185,7 @@ public void run() { config.sslContext = sslContext; config.tlsServerName = tlsServerName; config.taskQueue = pieces[1]; + config.role = role; if (pieces.length == 3) { config.nexusEndpoint = pieces[2]; } @@ -213,4 +224,14 @@ public void run() { public static void main(String... args) { System.exit(new CommandLine(new Main()).execute(args)); } + + @SuppressWarnings("unchecked") + private PreparedFeature[] crossLanguageFeature(String dir) { + try { + return PreparedFeature.prepareFeatures( + (Class) Class.forName(dir.replace('/', '.') + ".feature$Impl")); + } catch (ClassNotFoundException e) { + throw new IllegalArgumentException("No Java participant for " + dir, e); + } + } } diff --git a/harness/java/io/temporal/sdkfeatures/Runner.java b/harness/java/io/temporal/sdkfeatures/Runner.java index fee9056a..e3952892 100644 --- a/harness/java/io/temporal/sdkfeatures/Runner.java +++ b/harness/java/io/temporal/sdkfeatures/Runner.java @@ -38,6 +38,7 @@ public class Runner implements Closeable { private static final Logger log = LoggerFactory.getLogger(Main.class); public static class Config { + public String role; public String serverHostPort; public String namespace; public String taskQueue; @@ -91,7 +92,9 @@ public static class Config { client = WorkflowClient.newInstance(service, clientBuild.build()); // Build worker - restartWorker(); + if (!"client".equals(config.role)) { + restartWorker(); + } } catch (Throwable e) { service.shutdownNow(); throw e; @@ -132,6 +135,11 @@ public void restartWorker() { } void run() throws Exception { + if ("worker".equals(config.role)) { + System.out.println("FEATURE_WORKER_READY"); + new java.util.concurrent.CountDownLatch(1).await(); + return; + } log.info("Executing feature {}", featureInfo.dir); var run = feature.execute(this); if (run == null) { @@ -322,7 +330,9 @@ public Map loadPastHistories() throws Excep public void close() { try { - workerFactory.shutdownNow(); + if (workerFactory != null) { + workerFactory.shutdownNow(); + } } catch (Throwable e) { try { service.shutdownNow(); diff --git a/harness/python/feature.py b/harness/python/feature.py index 25826250..0ed58ec5 100644 --- a/harness/python/feature.py +++ b/harness/python/feature.py @@ -130,6 +130,7 @@ def __init__( feature: Feature, tls_config: Optional[TLSConfig], http_proxy_url: Optional[str], + role: Optional[str] = None, ) -> None: self.address = address self.namespace = namespace @@ -143,6 +144,7 @@ def __init__( self.tls_config = tls_config self.http_proxy_url = http_proxy_url self.client: Client + self.role = role async def run(self) -> None: logger.info("Executing feature %s", self.feature.rel_dir) @@ -157,8 +159,13 @@ async def run(self) -> None: ) # Run worker - self.start_worker() + if self.role != "client": + self.start_worker() try: + if self.role == "worker": + print("FEATURE_WORKER_READY", flush=True) + await self._worker_task + return # Start and get handle handle: WorkflowHandle if self.feature.start: diff --git a/harness/python/main.py b/harness/python/main.py index d27122de..ccd4d744 100644 --- a/harness/python/main.py +++ b/harness/python/main.py @@ -25,6 +25,7 @@ async def run(): "--ca-cert-path", help="Path to a CA certificate for server verification" ) parser.add_argument("--log-level", help="Log level", default="WARNING") + parser.add_argument("--role", choices=["client", "worker"]) parser.add_argument("--http-proxy-url", help="HTTP proxy URL") parser.add_argument( "--tls-server-name", help="TLS server name to use for verification (optional)" @@ -94,6 +95,7 @@ async def run(): feature=features[rel_dir], tls_config=tls_config, http_proxy_url=args.http_proxy_url if args.http_proxy_url else None, + role=args.role, ).run() except Exception: logger.exception("Feature %s failed", rel_dir) diff --git a/harness/ruby/lib/harness.rb b/harness/ruby/lib/harness.rb index cdc9ead3..6a90f52a 100644 --- a/harness/ruby/lib/harness.rb +++ b/harness/ruby/lib/harness.rb @@ -7,7 +7,9 @@ module Harness :expect_run_result, :expect_activity_error, :start_callback, - :check_result_callback + :check_result_callback, + :client_options, + :worker_options ) @features = {} @@ -22,7 +24,9 @@ def self.register_feature( expect_run_result: nil, expect_activity_error: nil, start: nil, - check_result: nil + check_result: nil, + client_options: {}, + worker_options: {} ) rel_dir = caller_feature_dir(caller_locations(1, 1).first.path) @features[rel_dir] = Feature.new( @@ -31,7 +35,9 @@ def self.register_feature( expect_run_result: expect_run_result, expect_activity_error: expect_activity_error, start_callback: start, - check_result_callback: check_result + check_result_callback: check_result, + client_options: client_options, + worker_options: worker_options ) end diff --git a/harness/ruby/runner.rb b/harness/ruby/runner.rb index b824a7da..f086ed88 100644 --- a/harness/ruby/runner.rb +++ b/harness/ruby/runner.rb @@ -67,6 +67,7 @@ def parse_args(argv) opts.on('--tls-server-name NAME', 'TLS server name override') { |v| @tls_server_name = v } opts.on('--http-proxy-url URL', 'HTTP proxy URL') { |v| @http_proxy_url = v } opts.on('--summary-uri URI', 'Where to stream the test summary JSONL') { |v| @summary_uri = v } + opts.on('--role ROLE', %w[client worker], 'Cross-language harness role') { |v| @role = v } end @features_arg = parser.parse(argv) @@ -97,8 +98,8 @@ def write_summary_entry(summary_io, entry) summary_io.flush end - def connect_client - connect_options = {} + def connect_client(feature) + connect_options = feature.client_options.dup if @client_cert_path raise ArgumentError, 'Client cert specified, but not client key!' unless @client_key_path @@ -131,7 +132,7 @@ def run_feature(rel_dir, task_queue) feature = Harness.features[rel_dir] raise "Feature #{rel_dir} not registered after loading" unless feature - client = connect_client + client = connect_client(feature) execute_feature(client, feature, rel_dir, task_queue) end @@ -143,16 +144,28 @@ def load_feature_file(rel_dir) end def execute_feature(client, feature, rel_dir, task_queue) + if @role == 'client' + handle = start_workflow(client, feature, rel_dir, task_queue) + check_result(client, handle, feature) + return + end worker = Temporalio::Worker.new( client: client, task_queue: task_queue, activities: feature.activities, - workflows: feature.workflows + workflows: feature.workflows, + **feature.worker_options ) worker.run do - handle = start_workflow(client, feature, rel_dir, task_queue) - check_result(client, handle, feature) + if @role == 'worker' + puts 'FEATURE_WORKER_READY' + $stdout.flush + Queue.new.pop + else + handle = start_workflow(client, feature, rel_dir, task_queue) + check_result(client, handle, feature) + end end end diff --git a/harness/rust/Cargo.lock b/harness/rust/Cargo.lock index 40052ea6..0ad4336e 100644 --- a/harness/rust/Cargo.lock +++ b/harness/rust/Cargo.lock @@ -102,6 +102,12 @@ dependencies = [ "syn 3.0.9", ] +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + [[package]] name = "bytes" version = "1.12.1" @@ -132,7 +138,7 @@ checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" dependencies = [ "cfg-if", "cpufeatures", - "rand_core", + "rand_core 0.10.1", ] [[package]] @@ -592,6 +598,18 @@ dependencies = [ "wasi", ] +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + [[package]] name = "getrandom" version = "0.4.3" @@ -600,8 +618,8 @@ checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" dependencies = [ "cfg-if", "libc", - "r-efi", - "rand_core", + "r-efi 6.0.0", + "rand_core 0.10.1", ] [[package]] @@ -900,6 +918,17 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "js-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dc09d2154098bbf4ef54eab6b117a3c24cbbffe94046b16ee6d6d4510584d3a" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + [[package]] name = "lazy_static" version = "1.5.1" @@ -1089,6 +1118,36 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" +[[package]] +name = "opentelemetry" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0142c63252a9e054e68a4c61a5778f7b14f576274d593f8ce883d191a099682" +dependencies = [ + "futures-core", + "futures-sink", + "js-sys", + "pin-project-lite", + "thiserror", + "tracing", +] + +[[package]] +name = "opentelemetry_sdk" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b59f80e1ac4d5ff7a2db8fb6c80badb7f0f3f858211fba08dd9aaec750894f9" +dependencies = [ + "futures-channel", + "futures-executor", + "futures-util", + "opentelemetry", + "percent-encoding", + "portable-atomic", + "rand 0.9.5", + "thiserror", +] + [[package]] name = "option-ext" version = "0.2.0" @@ -1216,6 +1275,15 @@ dependencies = [ "zerovec", ] +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + [[package]] name = "predicates" version = "3.1.4" @@ -1413,12 +1481,28 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "r-efi" version = "6.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha", + "rand_core 0.9.5", +] + [[package]] name = "rand" version = "0.10.3" @@ -1427,7 +1511,26 @@ checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" dependencies = [ "chacha20", "getrandom 0.4.3", - "rand_core", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", ] [[package]] @@ -1442,7 +1545,7 @@ version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a" dependencies = [ - "rand_core", + "rand_core 0.10.1", ] [[package]] @@ -1615,7 +1718,10 @@ dependencies = [ "anyhow", "clap", "futures", + "opentelemetry", + "opentelemetry_sdk", "percent-encoding", + "prost", "serde", "serde_json", "temporalio-client", @@ -1856,7 +1962,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.4.3", + "getrandom 0.3.4", "once_cell", "rustix", "windows-sys 0.61.2", @@ -1883,7 +1989,7 @@ dependencies = [ "hyper", "hyper-util", "parking_lot", - "rand", + "rand 0.10.3", "serde_json", "temporalio-common", "thiserror", @@ -2006,6 +2112,8 @@ dependencies = [ "derive_more", "futures-util", "gethostname", + "opentelemetry", + "opentelemetry_sdk", "parking_lot", "prost", "prost-wkt-types", @@ -2049,7 +2157,7 @@ dependencies = [ "pin-project", "prost", "prost-wkt-types", - "rand", + "rand 0.10.3", "serde", "serde_json", "siphasher", @@ -2081,7 +2189,7 @@ dependencies = [ "futures-util", "prost", "prost-wkt-types", - "rand", + "rand 0.10.3", "rand_pcg", "serde", "siphasher", @@ -2089,7 +2197,7 @@ dependencies = [ "temporalio-macros", "thiserror", "uuid", - "wit-bindgen", + "wit-bindgen 0.61.1", ] [[package]] @@ -2536,6 +2644,59 @@ version = "0.11.1+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen 0.57.1", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c" +dependencies = [ + "cfg-if", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e931a02a39abdbf66966fc35902b5ed58344750a70885bed4ebb3d8eaf28ed9" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ca4b54280e455bd831e33a6b8e734baf432fe63fbc35c42ac14ce67a043a53a" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.9", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b1f9c3798725016c6ee5f2f57869ec0831e8bbc0ab0310a86e787e97f41389e" +dependencies = [ + "unicode-ident", +] + [[package]] name = "wasm-encoder" version = "0.258.3" @@ -2790,6 +2951,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81" +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + [[package]] name = "wit-bindgen" version = "0.61.1" @@ -2909,6 +3076,26 @@ dependencies = [ "synstructure", ] +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "zerofrom" version = "0.1.8" diff --git a/harness/rust/Cargo.toml b/harness/rust/Cargo.toml index 789df51c..d1295051 100644 --- a/harness/rust/Cargo.toml +++ b/harness/rust/Cargo.toml @@ -6,6 +6,12 @@ publish = false [workspace] +[features] +cross-language = ["temporalio-sdk/experimental", "temporalio-sdk/opentelemetry", "dep:opentelemetry", "dep:opentelemetry_sdk", "dep:prost"] + +[build-dependencies] +serde_json = "1" + [[bin]] name = "program" path = "src/main.rs" @@ -29,3 +35,6 @@ tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "net", tokio-util = { version = "0.7", features = ["rt"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] } url = "2" +opentelemetry = { version = "0.32", optional = true } +opentelemetry_sdk = { version = "0.32", optional = true } +prost = { version = "0.14", optional = true } diff --git a/harness/rust/build.rs b/harness/rust/build.rs index 16e3f57d..1adad2a1 100644 --- a/harness/rust/build.rs +++ b/harness/rust/build.rs @@ -33,6 +33,14 @@ fn main() { let mut registry = String::new(); let mut entries = String::new(); for (index, source) in sources.into_iter().enumerate() { + let config = source.parent().unwrap().join("config.json"); + let cross_language = fs::read_to_string(config) + .ok() + .and_then(|text| serde_json::from_str::(&text).ok()) + .is_some_and(|config| config["crossLanguage"] == true); + if cross_language != env::var_os("CARGO_FEATURE_CROSS_LANGUAGE").is_some() { + continue; + } let key = source .parent() .unwrap() diff --git a/harness/rust/src/harness.rs b/harness/rust/src/harness.rs index 5369d95b..85471388 100644 --- a/harness/rust/src/harness.rs +++ b/harness/rust/src/harness.rs @@ -204,14 +204,23 @@ async fn run_feature( cancelled: &CancellationToken, ) -> Result { let worker_options = feature.worker_options(ctx)?; + let has_worker = worker_options.is_some(); let driver = async { + if options.role.as_deref() == Some("worker") { + ensure!(has_worker, "feature has no worker"); + println!("FEATURE_WORKER_READY"); + cancelled.cancelled().await; + return Ok(FeatureOutcome::Passed); + } tokio::select! { result = tokio::time::timeout(FEATURE_TIMEOUT, catch(feature.execute(ctx))) => result.context("feature execution timed out")?, _ = cancelled.cancelled() => bail!("execution cancelled"), } }; - let outcome = if let Some(mut worker_options) = worker_options { + let outcome = if let Some(mut worker_options) = + worker_options.filter(|_| options.role.as_deref() != Some("client")) + { // Give outstanding activities a finite grace period before SDK cancellation. if worker_options.graceful_shutdown_period.is_none() { worker_options.graceful_shutdown_period = Some(Duration::from_secs(5)); @@ -222,7 +231,10 @@ async fn run_feature( } else { driver.await? }; - if matches!(outcome, FeatureOutcome::Skipped(_)) || options.no_history_check { + if matches!(outcome, FeatureOutcome::Skipped(_)) + || options.no_history_check + || options.role.is_some() + { return Ok(outcome); } if let Some(replay_options) = feature.replay_options(ctx)? { diff --git a/harness/rust/src/options.rs b/harness/rust/src/options.rs index 1e904d3d..304eb18e 100644 --- a/harness/rust/src/options.rs +++ b/harness/rust/src/options.rs @@ -35,6 +35,8 @@ impl FromStr for Selection { #[derive(Parser)] #[command(disable_help_flag = true)] pub(crate) struct Options { + #[arg(long, value_parser = ["worker", "client"])] + pub role: Option, #[arg(long, value_parser = clap::builder::NonEmptyStringValueParser::new())] server: String, #[arg(long, value_parser = clap::builder::NonEmptyStringValueParser::new())] diff --git a/pyproject.toml b/pyproject.toml index 735cb3c5..94a2f0b1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,10 @@ description = "Temporal SDK Features" authors = [{ name = "Temporal Technologies Inc", email = "sdk@temporal.io" }] requires-python = ">=3.10" license = "MIT" -dependencies = ["temporalio"] +dependencies = [ + "temporalio", + "opentelemetry-sdk", +] [dependency-groups] dev = [ diff --git a/sdkbuild/java.go b/sdkbuild/java.go index ed46b9b0..abb85d8c 100644 --- a/sdkbuild/java.go +++ b/sdkbuild/java.go @@ -31,6 +31,8 @@ type BuildJavaProgramOptions struct { // NewCommand then runs directly. Otherwise NewCommand compiles and runs it // with gradle run. Build bool + // Additional SDK artifacts that must come from the selected SDK checkout/version. + SDKModules []string // If present, this directory is expected to exist beneath base dir. Otherwise // a temporary dir is created. DirName string @@ -115,6 +117,11 @@ dependencies { application { mainClass = '` + options.MainClass + `' }` + if options.Version != "" && !isPathDep { + for _, module := range append([]string{"temporal-sdk"}, options.SDKModules...) { + buildGradle += "\nconfigurations.configureEach { resolutionStrategy.force 'io.temporal:" + module + ":" + strings.TrimPrefix(options.Version, "v") + "' }\n" + } + } if err := os.WriteFile(filepath.Join(dir, "build.gradle"), []byte(buildGradle), 0644); err != nil { return nil, fmt.Errorf("failed writing build.gradle: %w", err) } @@ -130,6 +137,11 @@ application { includeBuild('` + asAbsPath + `') { dependencySubstitution { substitute module('io.temporal:temporal-sdk') using project(':temporal-sdk') +` + for _, module := range options.SDKModules { + settingsGradle += " substitute module('io.temporal:" + module + "') using project(':" + module + "')\n" + } + settingsGradle += ` } } ` diff --git a/sdkbuild/python.go b/sdkbuild/python.go index 67c4d0a0..2b627010 100644 --- a/sdkbuild/python.go +++ b/sdkbuild/python.go @@ -196,11 +196,17 @@ func PythonProgramFromDir(dir string) (*PythonProgram, error) { // Dir is the directory to run in. func (p *PythonProgram) Dir() string { return p.dir } -// NewCommand makes a new uv command. The first argument needs to be the +// NewCommand runs the prepared interpreter directly so cancellation owns the +// Python process, rather than leaving it behind an exited package-manager wrapper. +// The first argument needs to be the // name of the module. func (p *PythonProgram) NewCommand(ctx context.Context, args ...string) (*exec.Cmd, error) { - args = append([]string{"run", "python", "-m"}, args...) - cmd := exec.CommandContext(ctx, "uv", args...) + python := filepath.Join(p.dir, ".venv", "bin", "python") + if runtime.GOOS == "windows" { + python = filepath.Join(p.dir, ".venv", "Scripts", "python.exe") + } + args = append([]string{"-m"}, args...) + cmd := exec.CommandContext(ctx, python, args...) cmd.Dir = p.dir setupCommandIO(cmd, nil, nil) return cmd, nil diff --git a/sdkbuild/rust.go b/sdkbuild/rust.go index dd60a4b0..3020e1c4 100644 --- a/sdkbuild/rust.go +++ b/sdkbuild/rust.go @@ -26,7 +26,8 @@ type BuildRustProgramOptions struct { DirName string // Version selects an exact published SDK version, defaulting to Cargo.toml. // A value containing a slash or backslash selects a local SDK workspace. - Version string + Version string + CrossLanguage bool // If present, custom writers that will capture stdout/stderr. Stdout io.Writer Stderr io.Writer @@ -142,6 +143,9 @@ func BuildRustProgram(ctx context.Context, options BuildRustProgramOptions) (*Ru } } args := []string{"build", "--release", "--bin", "program", "--target-dir", target} + if options.CrossLanguage { + args = append(args, "--features", "cross-language") + } if locked { args = append(args, "--locked") } diff --git a/uv.lock b/uv.lock index 37b4e450..80129e4a 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.10" [options] @@ -14,6 +14,7 @@ name = "features" version = "0.1.0" source = { editable = "." } dependencies = [ + { name = "opentelemetry-sdk" }, { name = "temporalio" }, ] @@ -24,7 +25,10 @@ dev = [ ] [package.metadata] -requires-dist = [{ name = "temporalio" }] +requires-dist = [ + { name = "opentelemetry-sdk" }, + { name = "temporalio" }, +] [package.metadata.requires-dev] dev = [ @@ -184,6 +188,45 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/11/52/6327a5f4fda01207205038a106a99848a41c83e933cd23ea2cab3d2ebc6c/nexus_rpc-1.4.0-py3-none-any.whl", hash = "sha256:14c953d3519113f8ccec533a9efdb6b10c28afef75d11cdd6d422640c40b3a49", size = 29645, upload-time = "2026-02-25T22:01:33.122Z" }, ] +[[package]] +name = "opentelemetry-api" +version = "1.45.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" }, +] + +[[package]] +name = "opentelemetry-sdk" +version = "1.45.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" }, +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.66b1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" }, +] + [[package]] name = "pathspec" version = "1.0.4" From f57b5ae8dd928592e5f2e542f0a4e0eb69726795 Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Mon, 2 Nov 2026 10:58:35 -0800 Subject: [PATCH 4/6] Test TypeScript and Rust encoded tracing producers --- cmd/run_typescript.go | 1 + features/tracing/encoded_headers/README.md | 22 ++--- .../tracing/encoded_headers/driver/main.go | 4 +- .../encoded_headers/driver/main_test.go | 6 +- features/tracing/encoded_headers/feature.rs | 85 ++++++++++++++++--- features/tracing/encoded_headers/feature.ts | 55 ++++++++++-- harness/ts/harness.ts | 5 ++ package-lock.json | 66 +++++++++++++- package.json | 1 + 9 files changed, 206 insertions(+), 39 deletions(-) diff --git a/cmd/run_typescript.go b/cmd/run_typescript.go index 6fd8e751..9c80f530 100644 --- a/cmd/run_typescript.go +++ b/cmd/run_typescript.go @@ -49,6 +49,7 @@ func (p *Preparer) BuildTypeScriptProgram(ctx context.Context) (sdkbuild.Program "@opentelemetry/api": "1.9.0", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", } } else { // Cross-language participants may depend on newer SDK APIs than the ordinary diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md index 5190ab4e..c85cb63a 100644 --- a/features/tracing/encoded_headers/README.md +++ b/features/tracing/encoded_headers/README.md @@ -26,19 +26,15 @@ or manually rewrite tracing headers. | Java (`java`) | Yes | Yes | OpenTracing interceptors with the OpenTelemetry shim/W3C propagator and producer-specific `setEncodeHeaders(true)`; client codec | | Python (`py`) | Yes | Yes | `TracingInterceptor`, client `HeaderCodecBehavior.CODEC` and codec | | Ruby (`rb`) | Yes | Yes | OpenTelemetry tracing interceptor and client codec; worker codec thread pool | -| Rust (`rs`) | No | Yes | Experimental OpenTelemetry worker plugin and existing activation codec traversal | -| TypeScript (`ts`) | No | Yes | OpenTelemetry plugin, worker `codecHeaders: true` and payload codecs | +| Rust (`rs`) | Yes | Yes | OpenTelemetry plugin with `encode_client_headers(true)` and existing worker activation codec traversal | +| TypeScript (`ts`) | Yes | Yes | OpenTelemetry plugin with `encodeClientHeaders: true`, worker `codecHeaders: true`, and payload codecs | | PHP (`php`) | No | No | No SDK tracing integration in the inspected checkout; no participant is fabricated | -Rust's tracing client producer currently serializes an ordinary tracing carrier -without a producer-specific codec opt-in. It therefore cannot supply this -feature's encoded start header. Its worker already decodes activation headers -before tracing extraction and participates without SDK changes. The intentionally -closed Rust converter-wide encoding proposal is not needed or reinstated. -TypeScript's client tracing producer also emits a normally serialized carrier -and has no codec opt-in under the wire-ready client-header policy. It is therefore -unsupported as an encoded producer, not merely untested. The worker option -`codecHeaders` cannot enable client tracing production. +Rust and TypeScript encode only the tracing carrier produced by their plugins; +other client-supplied Payload headers remain wire-ready and untouched. These +producer opt-ins are independent of worker processing: Rust workers already decode +activation headers, while TypeScript workers use `codecHeaders`. The Rust +converter-wide encoding proposal is not needed or reinstated. PHP would first need a real tracing integration and a codec/header policy. ## Running @@ -73,6 +69,10 @@ without the opt-ins cannot run these producer participants and fail rather than silently testing unencoded headers. SDKs must be fixed/merged before this feature change lands. +Rust and TypeScript producer cases likewise require SDKs containing their new +OTel plugin flags. Select those checkouts with `--sdk-version rs=/path/to/sdk-rust` +and `--sdk-version ts=/path/to/sdk-typescript` while the changes are unreleased. + Use `ENCODED_HEADERS_PAIRS` only when focusing on particular scenarios: ```sh diff --git a/features/tracing/encoded_headers/driver/main.go b/features/tracing/encoded_headers/driver/main.go index 3f277e6d..4e5bfc24 100644 --- a/features/tracing/encoded_headers/driver/main.go +++ b/features/tracing/encoded_headers/driver/main.go @@ -49,7 +49,7 @@ func run() error { return errors.Join(failures...) } -var clients = []string{"cs", "go", "java", "py", "rb"} +var clients = []string{"cs", "go", "java", "py", "rb", "rs", "ts"} var workers = []string{"cs", "go", "java", "py", "rb", "rs", "ts"} func selectPairs(manifest *crosslanguage.Manifest, filter string) ([][2]string, error) { @@ -58,7 +58,7 @@ func selectPairs(manifest *crosslanguage.Manifest, filter string) ([][2]string, for _, selection := range strings.Split(filter, ",") { client, worker, ok := strings.Cut(selection, ":") if !ok || !slices.Contains(clients, client) || !slices.Contains(workers, worker) { - return nil, fmt.Errorf("invalid ENCODED_HEADERS_PAIRS pair %q: clients=%v workers=%v; PHP has no tracing integration; Rust/TS have no encoded tracing producer opt-in", selection, clients, workers) + return nil, fmt.Errorf("invalid ENCODED_HEADERS_PAIRS pair %q: clients=%v workers=%v; PHP has no tracing integration", selection, clients, workers) } if _, ok := manifest.Programs[client]; !ok { return nil, fmt.Errorf("client %s is not prepared; include --sdk-language %s", client, client) diff --git a/features/tracing/encoded_headers/driver/main_test.go b/features/tracing/encoded_headers/driver/main_test.go index 9d66b12c..7ccb737c 100644 --- a/features/tracing/encoded_headers/driver/main_test.go +++ b/features/tracing/encoded_headers/driver/main_test.go @@ -12,15 +12,15 @@ func TestPairSelection(t *testing.T) { "cs": {}, "ts": {}, "go": {}, }} pairs, err := selectPairs(manifest, "") - if err != nil || len(pairs) != 6 { - t.Fatalf("expected cs/go clients × cs/go/ts workers: %v %v", pairs, err) + if err != nil || len(pairs) != 9 { + t.Fatalf("expected cs/go/ts clients × cs/go/ts workers: %v %v", pairs, err) } pairs, err = selectPairs(manifest, "cs:ts,cs:ts") if err != nil || len(pairs) != 1 || pairs[0] != [2]string{"cs", "ts"} { t.Fatalf("unexpected focused selection: %v %v", pairs, err) } for filter, message := range map[string]string{ - "go:java": "not prepared", "rs:ts": "no encoded tracing producer", + "go:java": "not prepared", "rs:ts": "not prepared", "cs:php": "no tracing integration", } { if _, err := selectPairs(manifest, filter); err == nil || !strings.Contains(err.Error(), message) { diff --git a/features/tracing/encoded_headers/feature.rs b/features/tracing/encoded_headers/feature.rs index 129ba2d3..34424dc5 100644 --- a/features/tracing/encoded_headers/feature.rs +++ b/features/tracing/encoded_headers/feature.rs @@ -1,19 +1,19 @@ -use crate::harness::{Feature, FeatureContext, FeatureFuture}; -use anyhow::{Result, bail}; +use crate::harness::{Feature, FeatureContext, FeatureFuture, FeatureOutcome}; +use anyhow::{Result, ensure}; use futures::{FutureExt, future::BoxFuture}; use opentelemetry::{ Context, - trace::{TraceContextExt, TracerProvider}, + trace::{FutureExt as _, TraceContextExt, Tracer, TracerProvider}, }; use prost::Message; -use std::collections::HashMap; -use temporalio_client::{Client, ClientOptions}; +use std::{collections::HashMap, time::Duration}; +use temporalio_client::{Client, ClientOptions, WorkflowGetResultOptions}; use temporalio_common::{ data_converters::{ DataConverter, DefaultFailureConverter, PayloadCodec, PayloadConversionError, PayloadConverter, SerializationContextData, }, - protos::temporal::api::common::v1::Payload, + protos::temporal::api::{common::v1::Payload, history::v1::history_event::Attributes}, }; use temporalio_macros::{workflow, workflow_methods}; use temporalio_sdk::{ @@ -118,6 +118,12 @@ impl Feature for EncodedHeaders { DefaultFailureConverter::default(), WrappingCodec, )) + .plugin( + OpenTelemetryPlugin::builder() + .tracer(self.provider.tracer("encoded-headers-feature")) + .encode_client_headers(true) + .build(), + ) .build(); Ok(Client::new(client.connection().clone(), options)?) } @@ -125,19 +131,70 @@ impl Feature for EncodedHeaders { fn worker_options(&self, ctx: &FeatureContext) -> Result> { Ok(Some( WorkerOptions::new(ctx.task_queue.clone()) - .worker_plugin( - OpenTelemetryPlugin::builder() - .tracer(self.provider.tracer("encoded-headers-feature")) - .build(), - ) .register_workflow::()? .build(), )) } - fn execute<'a>(&'a self, _: &'a FeatureContext) -> FeatureFuture<'a> { - Box::pin(async { - bail!("Rust is worker-only: the client tracing producer has no codec opt-in") + fn execute<'a>(&'a self, ctx: &'a FeatureContext) -> FeatureFuture<'a> { + Box::pin(async move { + let tracer = self.provider.tracer("encoded-headers-feature"); + let parent = Context::new().with_span(tracer.start("rust-caller")); + let trace_id = parent.span().span_context().trace_id().to_string(); + let result = async { + let mut options = ctx.start_options(); + options.execution_timeout = Some(Duration::from_secs(15)); + let handle = ctx + .client + .start_workflow(Workflow::run, "hello".to_owned(), options) + .await?; + let result = handle.get_result(WorkflowGetResultOptions::default()).await; + let events = handle + .fetch_history(Default::default()) + .into_events() + .await?; + for event in &events { + ensure!( + !matches!( + event.attributes, + Some(Attributes::WorkflowTaskFailedEventAttributes(_)) + ), + "Workflow Task failed: {event:?}" + ); + } + let Some(Attributes::WorkflowExecutionStartedEventAttributes(started)) = + events.first().and_then(|event| event.attributes.as_ref()) + else { + anyhow::bail!("Missing workflow start event"); + }; + let header = &started.header.as_ref().unwrap().fields["_tracer-data"]; + let decoded = WrappingCodec + .decode( + &SerializationContextData::Workflow( + temporalio_common::data_converters::WorkflowSerializationContext::new(), + ), + vec![header.clone()], + ) + .await?; + let carrier: HashMap = serde_json::from_slice(&decoded[0].data)?; + ensure!( + carrier["traceparent"].split('-').nth(1) == Some(trace_id.as_str()), + "History trace identity mismatch" + ); + ensure!( + result? + == HashMap::from([ + ("message".to_owned(), "hello".to_owned()), + ("traceId".to_owned(), trace_id), + ]), + "Workflow input/result or trace identity mismatch" + ); + Ok(FeatureOutcome::Passed) + } + .with_context(parent.clone()) + .await; + parent.span().end(); + result }) } } diff --git a/features/tracing/encoded_headers/feature.ts b/features/tracing/encoded_headers/feature.ts index 9be1eea4..261c04fd 100644 --- a/features/tracing/encoded_headers/feature.ts +++ b/features/tracing/encoded_headers/feature.ts @@ -1,9 +1,12 @@ +import * as assert from 'node:assert/strict'; import { Resource } from '@opentelemetry/resources'; import { InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'; +import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'; import { Feature } from '@temporalio/harness'; -import { Payload, PayloadCodec } from '@temporalio/common'; +import { defaultPayloadConverter, Payload, PayloadCodec } from '@temporalio/common'; import { temporal } from '@temporalio/proto'; import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry'; +import { workflow } from './workflow'; const encoding = 'binary/encrypted'; const payloadProto = temporal.api.common.v1.Payload; @@ -32,19 +35,55 @@ class WrappingCodec implements PayloadCodec { } } -// Keep the codec on the worker boundary; an interceptor workaround would mask the regression. +const resource = new Resource({ 'service.name': 'encoded-headers-feature' }); +const spanProcessor = new SimpleSpanProcessor(new InMemorySpanExporter()); +const provider = new NodeTracerProvider({ resource, spanProcessors: [spanProcessor] }); +provider.register(); +const tracer = provider.getTracer('encoded-headers-feature'); +const tracingOptions = { resource, spanProcessor, tracer, encodeClientHeaders: true }; +const tracingPlugin = new OpenTelemetryPlugin(tracingOptions); + const workerOptions = { codecHeaders: true, - plugins: [ - new OpenTelemetryPlugin({ - resource: new Resource({ 'service.name': 'encoded-headers-feature' }), - spanProcessor: new SimpleSpanProcessor(new InMemorySpanExporter()), - }), - ], + plugins: [tracingPlugin], }; export const feature = new Feature({ + workflow, workflowsPath: require.resolve('./workflow'), dataConverter: { payloadCodecs: [new WrappingCodec()] }, + clientOptions: { plugins: [tracingPlugin] }, workerOptions, + execute: async (runner) => + tracer.startActiveSpan('ts-caller', async (parent) => { + try { + const handle = await runner.client.workflow.start(workflow, { + taskQueue: runner.options.taskQueue, + workflowId: `${runner.options.taskQueue}-workflow`, + workflowExecutionTimeout: '15s', + args: ['hello'], + }); + try { + const result = await handle.result(); + const events = (await handle.fetchHistory()).events!; + const header = events[0]!.workflowExecutionStartedEventAttributes!.header!.fields!['_tracer-data']!; + const [decoded] = await new WrappingCodec().decode([header]); + const carrier = defaultPayloadConverter.fromPayload<{ traceparent: string }>(decoded!); + assert.equal(carrier.traceparent.split('-')[1], parent.spanContext().traceId); + assert.deepEqual(result, { message: 'hello', traceId: parent.spanContext().traceId }); + assert.ok(events.every((event) => !event.workflowTaskFailedEventAttributes)); + return handle; + } catch (error) { + const events = (await handle.fetchHistory()).events!; + for (const event of events) { + if (event.workflowTaskFailedEventAttributes) { + console.error('Workflow Task failed:', event.workflowTaskFailedEventAttributes.failure); + } + } + throw error; + } + } finally { + parent.end(); + } + }), }); diff --git a/harness/ts/harness.ts b/harness/ts/harness.ts index 04797ae7..816e7e23 100644 --- a/harness/ts/harness.ts +++ b/harness/ts/harness.ts @@ -10,6 +10,7 @@ import { WorkflowStartOptions, TLSConfig, ConnectionOptions, + ClientOptions, } from '@temporalio/client'; import * as proto from '@temporalio/proto'; import { DataConverter, UntypedActivities, Workflow, WorkflowResultType } from '@temporalio/common'; @@ -27,6 +28,9 @@ export { getConnection, getClient, Context } from './activity-interceptors'; export type { ReplaceNested }; export interface FeatureOptions { + /** Additional client configuration, including client-side tracing plugins. */ + clientOptions?: Partial; + /** * Workflow to execute. This defaults to `import(workflowsPath).workflow` if * unset. @@ -142,6 +146,7 @@ export class Runner { connection, namespace: options.namespace, dataConverter: feature.options.dataConverter, + ...feature.options.clientOptions, }); // Create a connection for the Worker diff --git a/package-lock.json b/package-lock.json index f5846411..c94ac82c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,6 +12,7 @@ "@opentelemetry/api": "1.9.0", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", @@ -1297,6 +1298,18 @@ "node": ">=8.0.0" } }, + "node_modules/@opentelemetry/context-async-hooks": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz", + "integrity": "sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, "node_modules/@opentelemetry/core": { "version": "1.30.1", "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz", @@ -1312,6 +1325,37 @@ "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, + "node_modules/@opentelemetry/propagator-b3": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz", + "integrity": "sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/propagator-jaeger": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz", + "integrity": "sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==", + "deprecated": "Package no longer supported. See https://github.com/open-telemetry/opentelemetry-js/pull/7077", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, "node_modules/@opentelemetry/resources": { "version": "1.30.1", "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz", @@ -1346,6 +1390,27 @@ "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, + "node_modules/@opentelemetry/sdk-trace-node": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz", + "integrity": "sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==", + "deprecated": "Use @opentelemetry/sdk-trace package", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/context-async-hooks": "1.30.1", + "@opentelemetry/core": "1.30.1", + "@opentelemetry/propagator-b3": "1.30.1", + "@opentelemetry/propagator-jaeger": "1.30.1", + "@opentelemetry/sdk-trace-base": "1.30.1", + "semver": "^7.5.2" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, "node_modules/@opentelemetry/semantic-conventions": { "version": "1.28.0", "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz", @@ -6441,7 +6506,6 @@ "version": "7.7.4", "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, "license": "ISC", "bin": { "semver": "bin/semver.js" diff --git a/package.json b/package.json index e6c21585..a600ad5e 100644 --- a/package.json +++ b/package.json @@ -14,6 +14,7 @@ "@opentelemetry/api": "1.9.0", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", From 3c3cba4de49bc2b34dd3591aefd848ec7c1e05ae Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Thu, 12 Nov 2026 16:42:42 -0800 Subject: [PATCH 5/6] Validate published header codec SDK releases --- README.md | 4 +- features/go.mod | 4 +- features/go.sum | 8 +- features/tracing/encoded_headers/README.md | 66 +++++++++++----- go.mod | 4 +- go.sum | 8 +- harness/go/go.mod | 4 +- harness/go/go.sum | 8 +- harness/rust/Cargo.lock | 90 +++++++++++----------- harness/rust/Cargo.toml | 10 +-- uv.lock | 72 ++++++++++++++--- 11 files changed, 177 insertions(+), 101 deletions(-) diff --git a/README.md b/README.md index b624aeb4..2d8194ea 100644 --- a/README.md +++ b/README.md @@ -173,14 +173,14 @@ Use repeated `--sdk-version language=version-or-local-checkout` options to selec SDKs independently. For example: ```sh -go run . run-cross-language --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +go run . run-cross-language --sdk-version cs=1.22.0 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` Use repeated `--sdk-language` options to prepare only selected participants, without imposing pair policy on the runner. For the focused original regression: ```sh -go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +ENCODED_HEADERS_PAIRS=cs:ts go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.22.0 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` Go, Java, Python, Ruby, Rust, .NET and TypeScript harnesses expose separate roles. diff --git a/features/go.mod b/features/go.mod index 047d176d..c6a1d50a 100644 --- a/features/go.mod +++ b/features/go.mod @@ -14,8 +14,8 @@ require ( github.com/urfave/cli/v2 v2.3.0 go.opentelemetry.io/otel v1.44.0 go.opentelemetry.io/otel/sdk v1.44.0 - go.temporal.io/api v1.63.5 - go.temporal.io/sdk v1.49.0 + go.temporal.io/api v1.64.3 + go.temporal.io/sdk v1.51.0 go.temporal.io/sdk/contrib/aws/s3driver v0.1.1 go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2 v0.1.1 go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0 diff --git a/features/go.sum b/features/go.sum index db5e8ecf..ae413d7d 100644 --- a/features/go.sum +++ b/features/go.sum @@ -365,11 +365,11 @@ go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqe go.shabbyrobe.org/gocovmerge v0.0.0-20230507111327-fa4f82cfbf4d h1:Ns9kd1Rwzw7t0BR8XMphenji4SmIoNZPn8zhYmaVKP8= go.shabbyrobe.org/gocovmerge v0.0.0-20230507111327-fa4f82cfbf4d/go.mod h1:92Uoe3l++MlthCm+koNi0tcUCX3anayogF0Pa/sp24k= go.temporal.io/api v1.5.0/go.mod h1:BqKxEJJYdxb5dqf0ODfzfMxh8UEQ5L3zKS51FiIYYkA= -go.temporal.io/api v1.63.5 h1:c11+kPYHkXXL3UiShPdbMD+xtvqGsbTibUA9ypmiCa4= -go.temporal.io/api v1.63.5/go.mod h1:SrlW2JMwVlDP4nRWSNznUFqnSHd+YeMDS1BkYo63HCQ= +go.temporal.io/api v1.64.3 h1:Q2oP9jVB5pSputb2j3BLAEjJsi8A2tSzMojqcSGyga0= +go.temporal.io/api v1.64.3/go.mod h1:acM0I9WPuYg8W3Pd9jOZvEgi7mRUttUQ4+e7fowKVnM= go.temporal.io/sdk v1.12.0/go.mod h1:lSp3lH1lI0TyOsus0arnO3FYvjVXBZGi/G7DjnAnm6o= -go.temporal.io/sdk v1.49.0 h1:CtGI0BUe/SCo3eoqTwuWWtXKueii9GBVus7KrKKH1Vo= -go.temporal.io/sdk v1.49.0/go.mod h1:xP0FulN5JJSfisESUP60LlWsrKz2tLSStGjVdk8r5cc= +go.temporal.io/sdk v1.51.0 h1:RsEghFfg91qWgNaecRgPrms9TA7iXskSzSQO2BwhJRs= +go.temporal.io/sdk v1.51.0/go.mod h1:Gj2KwnQAlMhPRSX1RoqV3Zez8Y0U+6dCGxn1sg+j9kg= go.temporal.io/sdk/contrib/aws/s3driver v0.1.1 h1:cV0nhvb5rTDxP06L3XVAqwTSgFDXFVBFaA3b9dQl4rk= go.temporal.io/sdk/contrib/aws/s3driver v0.1.1/go.mod h1:/sYQljwSaVsL5bjdLeehUfKFlzA3y4jvbLShNv4PZ5Q= go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2 v0.1.1 h1:qNEdOWhbn+SeceOoCdd+WatLbIXFSuJa5EmiWhgH2F4= diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md index c85cb63a..e75e5c43 100644 --- a/features/tracing/encoded_headers/README.md +++ b/features/tracing/encoded_headers/README.md @@ -13,9 +13,9 @@ No interceptor decodes headers on an SDK's behalf. Every client checks that: All participants wrap the entire serialized protobuf `Payload` with XOR `0x5a` and set `metadata.encoding=binary/encrypted`. This deterministic test codec is -**not encryption**. Every codec rejects double encoding. Raw client-supplied -Payloads are wire-ready; this feature does not install a converter-wide wrapper -or manually rewrite tracing headers. +**not encryption**. Every codec rejects double encoding. User-provided Payload +headers must already include any required codec encoding; this feature does not +install a converter-wide wrapper or manually rewrite tracing headers. ## Participants @@ -31,12 +31,32 @@ or manually rewrite tracing headers. | PHP (`php`) | No | No | No SDK tracing integration in the inspected checkout; no participant is fabricated | Rust and TypeScript encode only the tracing carrier produced by their plugins; -other client-supplied Payload headers remain wire-ready and untouched. These +user-provided client Payload headers are unchanged. These producer opt-ins are independent of worker processing: Rust workers already decode -activation headers, while TypeScript workers use `codecHeaders`. The Rust -converter-wide encoding proposal is not needed or reinstated. +activation headers, while TypeScript workers use `codecHeaders`. PHP would first need a real tracing integration and a codec/header policy. +## Release availability + +The following versions were checked on November 13, 2026. Merged changes are not +necessarily published SDK releases. + +| SDK | Published version | Availability for this feature | +| --- | --- | --- | +| .NET | 1.22.0 | Available | +| Python | 1.36.0 | Available | +| Ruby | 1.11.0 | Available | +| Rust | 1.2.0 | Available; the harness pins this release | +| Go | SDK 1.51.0; OpenTelemetry module 0.8.1 | Blocked: the SDK contains the change, but the separately versioned OpenTelemetry module does not expose `EncodeHeaders` yet | +| Java | 1.40.0 | Blocked: the merged `setEncodeHeaders` option is not published yet | +| TypeScript | 1.25.0 | Blocked: the merged `codecHeaders` and `encodeClientHeaders` options are not published yet | + +Keep this feature PR in draft until the last three releases are available. Update +the Go OpenTelemetry dependency in `features/go.mod` and the TypeScript packages +in `package.json` when they are published; Java selects `latest.release`. +The default seven-language matrix remains enabled and must pass before landing. +Unreleased participants are not silently skipped or counted as successful. + ## Running By default, the runner discovers and prepares all participant files once. The @@ -46,37 +66,41 @@ deadline; failures are labeled and aggregated while later pairs continue. Worker are stopped and reaped on success, failure and cancellation. No tracing backend is required. -The original .NET → TypeScript case remains independently runnable: +Run the currently available releases without any local SDK checkouts: ```sh -go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.21.1 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +go run . run-cross-language \ + --sdk-language cs --sdk-language py --sdk-language rb --sdk-language rs \ + --sdk-version cs=1.22.0 --sdk-version py=1.36.0 \ + --sdk-version rb=1.11.0 --sdk-version rs=1.2.0 tracing/encoded_headers ``` -With `ts=1.25.0` this is a **failing regression test**, not an expected-failure -success: tracing extraction raises `Unknown encoding: binary/encrypted`. -The fixed TypeScript worker uses `codecHeaders`, not the removed data-converter -`encodeHeaders` flag. +This runs all 16 client/worker combinations among those four SDKs. -To validate the Go and Java producer opt-ins against branches under development: +The original .NET → TypeScript case remains independently runnable against a +checkout containing the merged TypeScript fix: ```sh -go run . run-cross-language --sdk-language go --sdk-language java --sdk-language py --sdk-version go=/path/to/sdk-go --sdk-version java=/path/to/sdk-java tracing/encoded_headers +ENCODED_HEADERS_PAIRS=cs:ts go run . run-cross-language \ + --sdk-language cs --sdk-language ts --sdk-version cs=1.22.0 \ + --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers ``` +With `ts=1.25.0` this is a **failing regression test**, not an expected-failure +success: tracing extraction raises `Unknown encoding: binary/encrypted`. + +Use `--sdk-version go=/path/to/sdk-go` and +`--sdk-version java=/path/to/sdk-java` to validate their merged but unreleased +tracing integrations. Local Go selection also substitutes its independently versioned OpenTelemetry module; local Java selection substitutes its OpenTracing module. Older releases without the opt-ins cannot run these producer participants and fail rather than -silently testing unencoded headers. SDKs must be fixed/merged before this feature -change lands. - -Rust and TypeScript producer cases likewise require SDKs containing their new -OTel plugin flags. Select those checkouts with `--sdk-version rs=/path/to/sdk-rust` -and `--sdk-version ts=/path/to/sdk-typescript` while the changes are unreleased. +silently testing unencoded headers. Use `ENCODED_HEADERS_PAIRS` only when focusing on particular scenarios: ```sh -ENCODED_HEADERS_PAIRS=py:rs go run . run-cross-language --sdk-language py --sdk-language rs --sdk-version rs=/path/to/sdk-rust tracing/encoded_headers +ENCODED_HEADERS_PAIRS=py:rs go run . run-cross-language --sdk-language py --sdk-language rs --sdk-version py=1.36.0 --sdk-version rs=1.2.0 tracing/encoded_headers ``` The filter is a comma-separated list of `client:worker` language codes. Requested diff --git a/go.mod b/go.mod index 4a49bb21..c46a7716 100644 --- a/go.mod +++ b/go.mod @@ -9,8 +9,8 @@ require ( github.com/temporalio/features/features v0.0.0-00010101000000-000000000000 github.com/temporalio/features/harness/go v0.0.0-00010101000000-000000000000 github.com/urfave/cli/v2 v2.25.7 - go.temporal.io/api v1.63.5 - go.temporal.io/sdk v1.49.0 + go.temporal.io/api v1.64.3 + go.temporal.io/sdk v1.51.0 golang.org/x/mod v0.38.0 google.golang.org/protobuf v1.36.11 gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum index 81b4a016..c08fa51e 100644 --- a/go.sum +++ b/go.sum @@ -210,11 +210,11 @@ go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/ go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.temporal.io/api v1.5.0/go.mod h1:BqKxEJJYdxb5dqf0ODfzfMxh8UEQ5L3zKS51FiIYYkA= -go.temporal.io/api v1.63.5 h1:c11+kPYHkXXL3UiShPdbMD+xtvqGsbTibUA9ypmiCa4= -go.temporal.io/api v1.63.5/go.mod h1:SrlW2JMwVlDP4nRWSNznUFqnSHd+YeMDS1BkYo63HCQ= +go.temporal.io/api v1.64.3 h1:Q2oP9jVB5pSputb2j3BLAEjJsi8A2tSzMojqcSGyga0= +go.temporal.io/api v1.64.3/go.mod h1:acM0I9WPuYg8W3Pd9jOZvEgi7mRUttUQ4+e7fowKVnM= go.temporal.io/sdk v1.12.0/go.mod h1:lSp3lH1lI0TyOsus0arnO3FYvjVXBZGi/G7DjnAnm6o= -go.temporal.io/sdk v1.49.0 h1:CtGI0BUe/SCo3eoqTwuWWtXKueii9GBVus7KrKKH1Vo= -go.temporal.io/sdk v1.49.0/go.mod h1:xP0FulN5JJSfisESUP60LlWsrKz2tLSStGjVdk8r5cc= +go.temporal.io/sdk v1.51.0 h1:RsEghFfg91qWgNaecRgPrms9TA7iXskSzSQO2BwhJRs= +go.temporal.io/sdk v1.51.0/go.mod h1:Gj2KwnQAlMhPRSX1RoqV3Zez8Y0U+6dCGxn1sg+j9kg= go.temporal.io/sdk/contrib/tally v0.2.0 h1:XnTJIQcjOv+WuCJ1u8Ve2nq+s2H4i/fys34MnWDRrOo= go.temporal.io/sdk/contrib/tally v0.2.0/go.mod h1:1kpSuCms/tHeJQDPuuKkaBsMqfHnIIRnCtUYlPNXxuE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= diff --git a/harness/go/go.mod b/harness/go/go.mod index e8a497a4..9309c054 100644 --- a/harness/go/go.mod +++ b/harness/go/go.mod @@ -7,8 +7,8 @@ require ( github.com/nexus-rpc/sdk-go v0.7.0 github.com/stretchr/testify v1.10.0 github.com/urfave/cli/v2 v2.3.0 - go.temporal.io/api v1.63.5 - go.temporal.io/sdk v1.49.0 + go.temporal.io/api v1.64.3 + go.temporal.io/sdk v1.51.0 go.uber.org/zap v1.19.1 golang.org/x/mod v0.38.0 google.golang.org/protobuf v1.36.11 diff --git a/harness/go/go.sum b/harness/go/go.sum index 7f97d951..6c302ae8 100644 --- a/harness/go/go.sum +++ b/harness/go/go.sum @@ -78,10 +78,10 @@ go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRk go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= -go.temporal.io/api v1.63.5 h1:c11+kPYHkXXL3UiShPdbMD+xtvqGsbTibUA9ypmiCa4= -go.temporal.io/api v1.63.5/go.mod h1:SrlW2JMwVlDP4nRWSNznUFqnSHd+YeMDS1BkYo63HCQ= -go.temporal.io/sdk v1.49.0 h1:CtGI0BUe/SCo3eoqTwuWWtXKueii9GBVus7KrKKH1Vo= -go.temporal.io/sdk v1.49.0/go.mod h1:xP0FulN5JJSfisESUP60LlWsrKz2tLSStGjVdk8r5cc= +go.temporal.io/api v1.64.3 h1:Q2oP9jVB5pSputb2j3BLAEjJsi8A2tSzMojqcSGyga0= +go.temporal.io/api v1.64.3/go.mod h1:acM0I9WPuYg8W3Pd9jOZvEgi7mRUttUQ4+e7fowKVnM= +go.temporal.io/sdk v1.51.0 h1:RsEghFfg91qWgNaecRgPrms9TA7iXskSzSQO2BwhJRs= +go.temporal.io/sdk v1.51.0/go.mod h1:Gj2KwnQAlMhPRSX1RoqV3Zez8Y0U+6dCGxn1sg+j9kg= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= diff --git a/harness/rust/Cargo.lock b/harness/rust/Cargo.lock index 0ad4336e..bc53b098 100644 --- a/harness/rust/Cargo.lock +++ b/harness/rust/Cargo.lock @@ -306,9 +306,9 @@ dependencies = [ [[package]] name = "dirs" -version = "6.0.0" +version = "7.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +checksum = "8d57d423b3c82e89b9a24ca3091fee61f456a26edbd28d26c65906f4bc1dcd8f" dependencies = [ "dirs-sys", ] @@ -985,9 +985,9 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" [[package]] name = "lru" -version = "0.18.5" +version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" +checksum = "4a9f71e3591c7ec44d3e563e87bf14ddc2bada8519dca046e5b0e560cd004e2d" dependencies = [ "hashbrown 0.17.1", ] @@ -1962,7 +1962,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.4", + "getrandom 0.4.3", "once_cell", "rustix", "windows-sys 0.61.2", @@ -1970,9 +1970,9 @@ dependencies = [ [[package]] name = "temporalio-client" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adee203bb632dd144574252f2519f6efee35c92b2a1dc99fc2a5345e5416a38d" +checksum = "f1d529c517ee4e71a4e1d9f773b392292639eefd0593c48377d124a8939a6309" dependencies = [ "anyhow", "async-trait", @@ -2004,9 +2004,9 @@ dependencies = [ [[package]] name = "temporalio-common" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdd8fe7008ab4539ad7e0649a55a34f237f60df7c30a03a69d75074262f1bb0" +checksum = "59744ea925fedf708b26baff7b059fc43f76d902d09fbbdbbd7668700e4fdfcd" dependencies = [ "anyhow", "async-trait", @@ -2042,9 +2042,9 @@ dependencies = [ [[package]] name = "temporalio-common-wasm" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "846575798b9f35125766dd40e632779de4407e6492011bacaba828337c0f3093" +checksum = "e067590d09c549cf22cd28f90cc64530743caf85a4f31bb7728b90011174bd77" dependencies = [ "anyhow", "async-trait", @@ -2069,20 +2069,20 @@ dependencies = [ [[package]] name = "temporalio-macros" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3f48f3a6ad84e1fc91323bb9aabff10a6ea6aca737eef9726f07e68f580f8c8" +checksum = "652321f14dfcc7b408166cba43c37bb61e0f239e550e6e296d004d38d33e2b14" dependencies = [ "proc-macro2", "quote", - "syn 2.0.119", + "syn 3.0.9", ] [[package]] name = "temporalio-protos" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdb4880e7150c234f60319c3b0994468f0b10f8a24c5620e4befc9d329f2ef67" +checksum = "b92fa39136fb7ea5b87d8981e3429779432b98994d1fcca36ad58925708706f9" dependencies = [ "anyhow", "base64 0.23.1", @@ -2102,9 +2102,9 @@ dependencies = [ [[package]] name = "temporalio-sdk" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59d223b6382f6f90b56d811266dd8f0ce56fa06fabf793056d2eb605fadbb266" +checksum = "7ded17a02f1a53b49b00cd9aeb5876188cb5ec7bf18f51051700946107b63039" dependencies = [ "anyhow", "async-trait", @@ -2133,9 +2133,9 @@ dependencies = [ [[package]] name = "temporalio-sdk-core" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53644dd3810c1cc5be51501c9284a03dbb6359cf68566222ae48e35a2fc7d04d" +checksum = "d808be0baca3e6d889ef8a728448840e51106f9a260276f93ffffe99b957d15d" dependencies = [ "anyhow", "async-trait", @@ -2178,9 +2178,9 @@ dependencies = [ [[package]] name = "temporalio-workflow" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36202ab42aac8760c693f3aeb90da88f4edfa0d963b33b062d6a035dc2baa90a" +checksum = "3e8686c6e4dd3cd1e1c4c83196fffcb4a45600a88828bb4917ae57cb127fa336" dependencies = [ "anyhow", "bon", @@ -2197,7 +2197,7 @@ dependencies = [ "temporalio-macros", "thiserror", "uuid", - "wit-bindgen 0.61.1", + "wit-bindgen 0.62.0", ] [[package]] @@ -2699,9 +2699,9 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f64765e43c000fae008a48db8b288e175e237fc9ce20a26586836878c1bee89f" +checksum = "b1d0246511d901aacf25d2dc9111f0054947de5e093fe662099e709ff7530dc3" dependencies = [ "leb128fmt", "wasmparser", @@ -2709,9 +2709,9 @@ dependencies = [ [[package]] name = "wasm-metadata" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47e10808eb27efde692f1b1706089fe19296728bf872291f5b4e0d50fba88f2f" +checksum = "4e7bf119eb01f4a246864c10bd87c8f26c566350abb25aa4d5273c415bbab338" dependencies = [ "anyhow", "indexmap", @@ -2721,9 +2721,9 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe9269dd817e0e7021bf534ccd9761bc2d64778b6708e41228b8439d75eaa0b1" +checksum = "0f7c12eac7bb587801590f6a67ff0bc84d0748513864b71108e4b311cc3df694" dependencies = [ "bitflags", "hashbrown 0.17.1", @@ -2959,9 +2959,9 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" [[package]] name = "wit-bindgen" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e473fd0095479f9689ac7d2a52c427cc96bb2b973ace50238dfcc1ab1cd52d93" +checksum = "53cb4b5556c3a791e86838ea287782bdafa704d55b0e68b5b81a3a16b9ea5f4b" dependencies = [ "bitflags", "wit-bindgen-rust-macro", @@ -2969,9 +2969,9 @@ dependencies = [ [[package]] name = "wit-bindgen-core" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87445680dfe6d6b5369e884bd63c03a3335268e855365b2fc3f7bcdce96a630e" +checksum = "72ad22a37ecbc0e1fdca34d2b670ba41368cb0920735643e00fdf39a16ee5431" dependencies = [ "anyhow", "heck", @@ -2980,15 +2980,15 @@ dependencies = [ [[package]] name = "wit-bindgen-rust" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72f2fe494de0d898216caf0fd0ae76af75753fcb3ff4f465b46131537cf24cf8" +checksum = "84ba5213d4332c260a0d4e69e34b0f7e4b85ddae10b6ebfbac00d9c185ba628a" dependencies = [ "anyhow", "heck", "indexmap", - "prettyplease 0.2.37", - "syn 2.0.119", + "prettyplease 0.3.0", + "syn 3.0.9", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -2996,24 +2996,24 @@ dependencies = [ [[package]] name = "wit-bindgen-rust-macro" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59283a01aec94f60f92ada22ffe182a5cea8acfce43be3be688de8d52df55312" +checksum = "8f19d63da8e478a370ef8192d90ccb517965b7747d6b46cd2d831dd0ef4d2541" dependencies = [ "anyhow", - "prettyplease 0.2.37", + "prettyplease 0.3.0", "proc-macro2", "quote", - "syn 2.0.119", + "syn 3.0.9", "wit-bindgen-core", "wit-bindgen-rust", ] [[package]] name = "wit-component" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0fca88950af0c1f42bc77e17315e48798b8d68340171b6d204f62bc19a878a6" +checksum = "092f783dee3253265fcde131475055f8c275ac0176a9c0396db1dc7b5544bfb4" dependencies = [ "anyhow", "bitflags", @@ -3030,9 +3030,9 @@ dependencies = [ [[package]] name = "wit-parser" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72a2127663dcf3ee16614fb0e3c33d5c6c66fec9dad317a8b0fdd3869487a533" +checksum = "6390f4f02493ce678d509c859cf1698e38929fb75c8012a6ee2f7d6b6cb66cd7" dependencies = [ "anyhow", "hashbrown 0.17.1", diff --git a/harness/rust/Cargo.toml b/harness/rust/Cargo.toml index d1295051..dac0cc7e 100644 --- a/harness/rust/Cargo.toml +++ b/harness/rust/Cargo.toml @@ -20,11 +20,11 @@ path = "src/main.rs" protoc-version = "36.1" [dependencies] -temporalio-sdk = "=1.1.0" -temporalio-client = "=1.1.0" -temporalio-workflow = "=1.1.0" -temporalio-macros = "=1.1.0" -temporalio-common = "=1.1.0" +temporalio-sdk = "=1.2.0" +temporalio-client = "=1.2.0" +temporalio-workflow = "=1.2.0" +temporalio-macros = "=1.2.0" +temporalio-common = "=1.2.0" anyhow = "1" clap = { version = "4", default-features = false, features = ["derive", "std", "error-context"] } futures = "0.3" diff --git a/uv.lock b/uv.lock index 80129e4a..d00550f9 100644 --- a/uv.lock +++ b/uv.lock @@ -1,6 +1,10 @@ version = 1 revision = 5 requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.11'", + "python_full_version < '3.11'", +] [options] exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values. @@ -15,7 +19,8 @@ version = "0.1.0" source = { editable = "." } dependencies = [ { name = "opentelemetry-sdk" }, - { name = "temporalio" }, + { name = "temporalio", version = "1.35.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "temporalio", version = "1.36.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, ] [package.dev-dependencies] @@ -180,6 +185,9 @@ wheels = [ name = "nexus-rpc" version = "1.4.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] dependencies = [ { name = "typing-extensions" }, ] @@ -188,6 +196,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/11/52/6327a5f4fda01207205038a106a99848a41c83e933cd23ea2cab3d2ebc6c/nexus_rpc-1.4.0-py3-none-any.whl", hash = "sha256:14c953d3519113f8ccec533a9efdb6b10c28afef75d11cdd6d422640c40b3a49", size = 29645, upload-time = "2026-02-25T22:01:33.122Z" }, ] +[[package]] +name = "nexus-rpc" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.11'", +] +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/e5/25be948c92492cfc8ac24a524ad8828fe0cb9f71f46a974d7a37f0794a26/nexus_rpc-1.5.0.tar.gz", hash = "sha256:be2d6934414677bc9dd8e571fb5106c22b8769edc19562c3f49d9988edd24e1c", size = 97404, upload-time = "2026-10-28T17:12:21.82Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/e2/00541e7997f3dfb294f7be3dafea3307ea09b9d3fd332054fe4d30627efc/nexus_rpc-1.5.0-py3-none-any.whl", hash = "sha256:5d6e856972be812573948df02da2257344c407a8eaa99977b5d38be54448305a", size = 30406, upload-time = "2026-10-28T17:12:20.245Z" }, +] + [[package]] name = "opentelemetry-api" version = "1.45.1" @@ -299,22 +322,51 @@ wheels = [ [[package]] name = "temporalio" -version = "1.27.2" +version = "1.35.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "nexus-rpc", version = "1.4.0", source = { registry = "https://pypi.org/simple" } }, + { name = "protobuf" }, + { name = "python-dateutil" }, + { name = "types-protobuf" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/38/03641a02eb18e2b16f58c1c136deafdffeb30828dcd83ebd8ac41eb39fd7/temporalio-1.35.0.tar.gz", hash = "sha256:c7a14f29909f8d847f78de49305af89c0ec5aea39272cd4050124386ac3ca295", size = 2879693, upload-time = "2026-10-28T20:13:38.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/d9/8bda464beda3adb897d8d9f0e5fa26b28f2bf63c831c6800cbd73f7728cb/temporalio-1.35.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:ac3ab920cc05e24a1d420688a49aabed7b2be8f25dd275200dfa839be30980fd", size = 13989719, upload-time = "2026-10-28T20:13:16.897Z" }, + { url = "https://files.pythonhosted.org/packages/26/c1/94861d72cbe5e1778fcd4685db63231af01d40ad99f0375b4df6d4e60d06/temporalio-1.35.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:51bae017d484450084daa19afafad12fa0af1a00af351ba304104d7b97b44f9a", size = 13552491, upload-time = "2026-10-28T20:13:19.725Z" }, + { url = "https://files.pythonhosted.org/packages/3c/ed/a776afec1033f749ec8f4c0c5264167aedc56a108a5adebfa4084af8aa82/temporalio-1.35.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b93845a2200d23b8edc9a8b0bf78b58bdb5e78721602b3f64072867e07e28504", size = 13927445, upload-time = "2026-10-28T20:13:21.984Z" }, + { url = "https://files.pythonhosted.org/packages/ca/0b/bf0ed1f1b623e1ffd5c21c9e65a331a5c1c4f77f3829dc99ceae99b69f39/temporalio-1.35.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45b5438f41ab154eda4eea40069df2fa8779cb8f5c27f266b917a700bfba8bb8", size = 14386743, upload-time = "2026-10-28T20:13:28.201Z" }, + { url = "https://files.pythonhosted.org/packages/76/d6/373d5ffe28263fc56ea0013bdd45715b4ff84f97d1052519b7c0d9ecd437/temporalio-1.35.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:8a5ce8b1e9c9e2df5fb9f17a345c0ef0a132c787cef8cf5a6593b5d707648253", size = 13988280, upload-time = "2026-10-28T20:13:31.667Z" }, + { url = "https://files.pythonhosted.org/packages/9c/41/47ad6f26002f84d8293d99098c414f75e9e8ff7955d034b7121bd211649b/temporalio-1.35.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:96310ae91b098c9fe2194f0892cef25381e8f870e48d5c069230312bbd1c6262", size = 14494297, upload-time = "2026-10-28T20:13:33.988Z" }, + { url = "https://files.pythonhosted.org/packages/db/33/30942b2d568df2c50089e381ee63b2d141f2ebfb7b4787bac3540f5cf617/temporalio-1.35.0-cp310-abi3-win_amd64.whl", hash = "sha256:6f434c0d3b6d049f4473f9f5d3e80b5e80c986440fd0490f2ee70cc631cbcddd", size = 15317073, upload-time = "2026-10-28T20:13:36.195Z" }, +] + +[[package]] +name = "temporalio" +version = "1.36.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.11'", +] dependencies = [ - { name = "nexus-rpc" }, + { name = "nexus-rpc", version = "1.5.0", source = { registry = "https://pypi.org/simple" } }, { name = "protobuf" }, - { name = "python-dateutil", marker = "python_full_version < '3.11'" }, { name = "types-protobuf" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/62/2bc1a9ad29382a3a99f088907ef2024a94420cfef340be1b33026c632828/temporalio-1.27.2.tar.gz", hash = "sha256:633bf2379492f3db1e887d1e64fdac00d9c2ddc3e9382b831d5af68256912e92", size = 2503041, upload-time = "2026-05-14T02:17:57.565Z" } +sdist = { url = "https://files.pythonhosted.org/packages/60/82/e1cdd6b33af79e38d2e3db350821d62b6daf188bc905013852dd480929bd/temporalio-1.36.0.tar.gz", hash = "sha256:e65a9d30a0e3647cb92f2b19254447b5297e26f0f5edd323b27ee406367543e4", size = 2923753, upload-time = "2026-11-11T01:08:39.067Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/64/85/9da14f9fbdfae95435d29353bb1c55891581ad6b23c86ca56e72d83035ed/temporalio-1.27.2-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:860f706380faafec8f183f9194d0883c8033a4211c5d19c2c962c45b06cf99e9", size = 14602829, upload-time = "2026-05-14T02:17:45.624Z" }, - { url = "https://files.pythonhosted.org/packages/24/51/b7437991e71eea082dc53222da11f064974917cd59063ba57e13e5895fbc/temporalio-1.27.2-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:a8dc0c680e351f3132809861888d8326dbd5030dd4e570663597e7d4768d9502", size = 13997680, upload-time = "2026-05-14T02:17:53.968Z" }, - { url = "https://files.pythonhosted.org/packages/8c/5d/358065040e6f0cedbf669acd333622999eec737ff868ca7829d727b77746/temporalio-1.27.2-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:805f3de4d193dec52e040e41dbfc9ab44be0206d2e81142ceefaf7b7208058d1", size = 14252199, upload-time = "2026-05-14T02:17:36.972Z" }, - { url = "https://files.pythonhosted.org/packages/72/8a/85d2eab07c3e23fc1124203e76857c69ab9b22d8ccebad0835e294edb754/temporalio-1.27.2-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5bc996cb501b8a918f50037ccee6facb05bb70984acada4c2a3e01f5e7957a38", size = 14779945, upload-time = "2026-05-14T02:18:05.513Z" }, - { url = "https://files.pythonhosted.org/packages/67/81/c9b08609e2a92ecf62c97c59cabfa0608337c8d5cc9941eed5d9a7778840/temporalio-1.27.2-cp310-abi3-win_amd64.whl", hash = "sha256:62a84ae9a60c17932971e4ca3b0f3cd6f32f173b8183e759989376503fb95af6", size = 14981897, upload-time = "2026-05-14T02:17:27.333Z" }, + { url = "https://files.pythonhosted.org/packages/8c/82/3696a76e35452f1960764027b41bff6c52ad5f70cd9d968dd49dc0efdd5c/temporalio-1.36.0-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:042f00e7ad1935c017ca4e964af1c88a1d45ac21f73e455b3f81b2c55a0bcab5", size = 14091242, upload-time = "2026-11-11T01:08:18.938Z" }, + { url = "https://files.pythonhosted.org/packages/a0/79/908bc9218f248f45581f0d4dce338ba5ae2b9fd1b5d20f2dd00b67e54366/temporalio-1.36.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:f3218255207aa37313adc0ae46332089411cb6e240d82a415ba39f8da4de64bd", size = 13648068, upload-time = "2026-11-11T01:08:22.372Z" }, + { url = "https://files.pythonhosted.org/packages/66/b3/4d6dd7d57901e7038263775c84312f523a31bbeb3a5d45958f782f18e36a/temporalio-1.36.0-cp311-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:318f6b3f2315cf1c06c7896ab6c312791b6f9a426bab0a80c42a57af156acc20", size = 14050456, upload-time = "2026-11-11T01:08:25.454Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b6/0572b6211bcceda6b657c13e726ad2ce2959a5228d002d1bd327610de5af/temporalio-1.36.0-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed457244ed5185a3e4a2ecccd40bff1d11583380b9b80ecf314589463540f3f8", size = 14524738, upload-time = "2026-11-11T01:08:28.079Z" }, + { url = "https://files.pythonhosted.org/packages/1e/9a/ffb5f15773b87cb461f5eeb02f5b6ff493e77e08067e9e0f7da4f57e22da/temporalio-1.36.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d45faa8cb1cc047990e4d61c755e34a843d557e858667da9b175c550373607ab", size = 14132850, upload-time = "2026-11-11T01:08:30.474Z" }, + { url = "https://files.pythonhosted.org/packages/46/e2/d3fde3487dc3430e3c3291e90e52788f47183fc80c2c1dc08e0aa4eade86/temporalio-1.36.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8cf5dfe59a54d2ff1e8a9e3397457661bf560dcd3b9b9ddc07f7c6757f8a3dac", size = 14627513, upload-time = "2026-11-11T01:08:33.428Z" }, + { url = "https://files.pythonhosted.org/packages/76/d8/95ec26dcb35ef2dd35eae52e9e5223f148b21c05344d46ca29d746ebefe9/temporalio-1.36.0-cp311-abi3-win_amd64.whl", hash = "sha256:74940ad05bebf84e1c53a9f10a69addd10b819985286cd5e05c8b48340ded815", size = 15472448, upload-time = "2026-11-11T01:08:36.551Z" }, ] [[package]] From 6ab31384e51d71765aa3b76d5bdd5e11ebba665d Mon Sep 17 00:00:00 2001 From: Spencer Judge Date: Thu, 12 Nov 2026 16:47:37 -0800 Subject: [PATCH 6/6] Update cross-language SDK selection example --- cmd/run_cross_language.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/run_cross_language.go b/cmd/run_cross_language.go index 0b4142cf..8d6cf7e6 100644 --- a/cmd/run_cross_language.go +++ b/cmd/run_cross_language.go @@ -31,7 +31,7 @@ func runCrossLanguageCmd() *cli.Command { Flags: append([]cli.Flag{ &cli.StringSliceFlag{ Name: "sdk-version", Destination: &config.SDKVersions, - Usage: "SDK selection, e.g. cs=1.21.1 or ts=/path/to/sdk", + Usage: "SDK selection, e.g. cs=1.22.0 or ts=/path/to/sdk", }, &cli.StringSliceFlag{ Name: "sdk-language", Destination: &config.SDKLanguages,