Merge remote-tracking branch 'origin/main' into yunchuwang/functions-grpc-support

Brings in #290 (failure-details spans) and #303 (Functions host E2E suite
+ functions-e2e-tests workflow) so the E2E surface exists on this branch.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6e5be22b-b727-4ccf-8668-60397bb403a0

Author: YunchuWang

.github/workflows/functions-e2e-tests.yaml

@@ -0,0 +1,79 @@
+name: 🧪 Functions Host E2E Tests
+
+# Gated Azure Functions host E2E suite. It launches a real `func start` host for
+# test/e2e-functions/test-app (backed by Azurite / AzureStorage) and drives the
+# app over HTTP, porting the extension repo's `BasicNode` app + xUnit tests.
+#
+# The test-app depends on the PUBLISHED `durable-functions` + `@azure/functions`
+# packages, so it installs and runs without any in-repo package build. The suite
+# self-gates: each spec SKIPS cleanly when the Azure Functions Core Tools (`func`)
+# or the Azurite storage emulator are unavailable, and RUNS when both are present.
+# In CI below we install and start both, so the suite runs for real; the self-skip
+# is the safety net that keeps the job green if a prerequisite fails to come up.
+#
+# Triggering: this suite is run ad hoc (manual dispatch) for now while it beds in,
+# so it does not gate day-to-day PRs. Start it from the Actions tab via "Run
+# workflow" (workflow_dispatch). To re-enable automatic runs on pull requests
+# later, add a `pull_request` trigger scoped to `test/e2e-functions/**` and this
+# workflow file. NOTE: workflow_dispatch only appears in the Actions UI once this
+# file exists on the repository's default branch.
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  functions-e2e-tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: ["22.x"]
+    name: "functions-e2e (node ${{ matrix.node-version }})"
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: 📥 Checkout code
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+
+      - name: ⚙️ NodeJS - Install
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: ${{ matrix.node-version }}
+          registry-url: "https://registry.npmjs.org"
+
+      # Root install provides jest + ts-jest used to run the spec files. The specs
+      # do not depend on the core durabletask-js packages, so no workspace build is
+      # required here.
+      - name: ⚙️ Install dependencies
+        run: npm ci
+
+      - name: 🔧 Install Azurite and Azure Functions Core Tools
+        run: npm install -g azurite azure-functions-core-tools@4
+
+      - name: 🗄️ Start Azurite
+        run: |
+          mkdir -p /tmp/azurite
+          azurite --silent --location /tmp/azurite \
+            --blobPort 10000 --queuePort 10001 --tablePort 10002 &
+          echo "Waiting for Azurite blob endpoint..."
+          for i in $(seq 1 30); do
+            if (echo > /dev/tcp/127.0.0.1/10000) >/dev/null 2>&1; then
+              echo "Azurite is up."
+              break
+            fi
+            sleep 1
+          done
+
+      # Installs the PUBLISHED durable-functions / @azure/functions packages and
+      # compiles the ported BasicNode app to dist/ (consumed by `func start`).
+      - name: 📦 Install + build test-app
+        working-directory: test/e2e-functions/test-app
+        run: |
+          npm install
+          npm run build
+
+      - name: ✅ Run Functions host E2E tests
+        run: npm run test:e2e:functions:internal
+        timeout-minutes: 20

.prettierignore

@@ -7,3 +7,7 @@ dist
 coverage
 # don't lint proto files and output
 proto
+
+# ported Azure Functions sample app — kept close to
+# azure-functions-durable-js's BasicNode (its own 4-space toolchain)
+test/e2e-functions/test-app

eslint.config.mjs

@@ -39,7 +39,11 @@ export default tseslint.config(
       "**/node_modules/**",
       "**/src/version.ts",
       "**/jest.config.js",
+      "jest.functions-e2e.config.js",
       "**/src/proto/**",
+      // Ported Azure Functions sample app (from azure-functions-durable-js's
+      // `BasicNode`), kept close to source and with its own 4-space toolchain.
+      "test/e2e-functions/test-app/**",
     ],
   }
 );

jest.functions-e2e.config.js

@@ -0,0 +1,27 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+//
+// Dedicated jest config for the gated Azure Functions host e2e suite. It is
+// intentionally NOT part of the default `npm test` / workspaces test run and is
+// only executed via `npm run test:e2e:functions:internal`. These specs drive a
+// real `func start` host over HTTP and skip cleanly without the local toolchain.
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/test/e2e-functions"],
+  testMatch: ["**/test/e2e-functions/**/*.spec.ts"],
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+  transform: {
+    "^.+\\.tsx?$": [
+      "ts-jest",
+      {
+        tsconfig: "tsconfig.base.json",
+      },
+    ],
+  },
+  globalSetup: "<rootDir>/test/e2e-functions/global-setup.ts",
+  globalTeardown: "<rootDir>/test/e2e-functions/global-teardown.ts",
+  // Host cold-start (extension-bundle download + worker spin-up) dominates.
+  testTimeout: 300_000,
+};

package.json

@@ -18,6 +18,8 @@
     "test:e2e:one": "jest tests/e2e --runInBand --detectOpenHandles --testNamePattern",
     "test:e2e:azuremanaged:internal": "jest test/e2e-azuremanaged --detectOpenHandles",
     "test:e2e:azuremanaged": "./scripts/test-e2e-azuremanaged.sh",
+    "test:e2e:functions:internal": "jest -c jest.functions-e2e.config.js --runInBand --detectOpenHandles",
+    "test:e2e:functions": "./scripts/test-e2e-functions.sh",
     "lint": "eslint .",
     "pretty": "prettier --list-different \"**/*.{ts,tsx,js,jsx,json,md}\"",
     "pretty-fix": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",

packages/durabletask-js/src/tracing/trace-helper.ts

@@ -690,9 +690,17 @@ export function setOrchestrationStatusFromActions(
         span.setAttribute(DurableTaskAttributes.TASK_STATUS, statusName);
       }
 
-      // Match .NET: set span error status when orchestration completes with Failed
+      // Match .NET: set span error status when orchestration completes with Failed.
+      // Read error message from failureDetails (where setFailed() stores it),
+      // falling back to result for backwards compatibility. Use nullish coalescing
+      // (like the task/sub-orchestration failure paths above and .NET's TraceHelper)
+      // so an explicitly empty failureDetails message is preserved rather than
+      // masked by the generic fallback.
       if (status === pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED) {
-        const errorMessage = completeAction.getResult()?.getValue() ?? "Orchestration failed";
+        const errorMessage =
+          completeAction.getFailuredetails()?.getErrormessage() ??
+          completeAction.getResult()?.getValue() ??
+          "Orchestration failed";
         span.setStatus({ code: otel.SpanStatusCode.ERROR, message: errorMessage });
       } else {
         span.setStatus({ code: otel.SpanStatusCode.OK });

packages/durabletask-js/test/tracing.spec.ts

@@ -1124,15 +1124,17 @@ describe("Trace Helper - setOrchestrationStatusFromActions", () => {
     expect(spans[0].status.code).toBe(otel.SpanStatusCode.OK);
   });
 
-  it("should set status attribute for failed orchestration and ERROR span status", () => {
+  it("should set status attribute for failed orchestration and ERROR span status with failureDetails", () => {
     const tracer = otel.trace.getTracer(TRACER_NAME);
     const span = tracer.startSpan("orch-status-failed");
 
+    // Match the real runtime path: setFailed() sets failureDetails but NOT result
     const completeAction = new pb.CompleteOrchestrationAction();
     completeAction.setOrchestrationstatus(pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED);
-    const resultValue = new StringValue();
-    resultValue.setValue("User code threw an error");
-    completeAction.setResult(resultValue);
+    const failureDetails = new pb.TaskFailureDetails();
+    failureDetails.setErrormessage("User code threw an error");
+    failureDetails.setErrortype("Error");
+    completeAction.setFailuredetails(failureDetails);
 
     const action = new pb.OrchestratorAction();
     action.setCompleteorchestration(completeAction);
@@ -1146,6 +1148,74 @@ describe("Trace Helper - setOrchestrationStatusFromActions", () => {
     expect(spans[0].status.message).toBe("User code threw an error");
   });
 
+  it("should fall back to result field for failed orchestration error message", () => {
+    const tracer = otel.trace.getTracer(TRACER_NAME);
+    const span = tracer.startSpan("orch-status-failed-result-fallback");
+
+    // Edge case: no failureDetails, but result is set (backwards compatibility)
+    const completeAction = new pb.CompleteOrchestrationAction();
+    completeAction.setOrchestrationstatus(pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED);
+    const resultValue = new StringValue();
+    resultValue.setValue("Legacy error message");
+    completeAction.setResult(resultValue);
+
+    const action = new pb.OrchestratorAction();
+    action.setCompleteorchestration(completeAction);
+
+    setOrchestrationStatusFromActions(span, [action]);
+    span.end();
+
+    const spans = exporter.getFinishedSpans();
+    expect(spans[0].status.code).toBe(otel.SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe("Legacy error message");
+  });
+
+  it("should use default error message when neither failureDetails nor result is set", () => {
+    const tracer = otel.trace.getTracer(TRACER_NAME);
+    const span = tracer.startSpan("orch-status-failed-no-details");
+
+    const completeAction = new pb.CompleteOrchestrationAction();
+    completeAction.setOrchestrationstatus(pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED);
+
+    const action = new pb.OrchestratorAction();
+    action.setCompleteorchestration(completeAction);
+
+    setOrchestrationStatusFromActions(span, [action]);
+    span.end();
+
+    const spans = exporter.getFinishedSpans();
+    expect(spans[0].status.code).toBe(otel.SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe("Orchestration failed");
+  });
+
+  it("should preserve an explicitly empty failureDetails message over the result/default fallback", () => {
+    const tracer = otel.trace.getTracer(TRACER_NAME);
+    const span = tracer.startSpan("orch-status-failed-empty-message");
+
+    // failureDetails is present (orchestration failed) but the error message is
+    // empty. failureDetails is authoritative, so nullish coalescing must keep the
+    // empty string rather than falling through to result/"Orchestration failed".
+    const completeAction = new pb.CompleteOrchestrationAction();
+    completeAction.setOrchestrationstatus(pb.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED);
+    const failureDetails = new pb.TaskFailureDetails();
+    failureDetails.setErrormessage("");
+    failureDetails.setErrortype("Error");
+    completeAction.setFailuredetails(failureDetails);
+    const resultValue = new StringValue();
+    resultValue.setValue("Should not be used");
+    completeAction.setResult(resultValue);
+
+    const action = new pb.OrchestratorAction();
+    action.setCompleteorchestration(completeAction);
+
+    setOrchestrationStatusFromActions(span, [action]);
+    span.end();
+
+    const spans = exporter.getFinishedSpans();
+    expect(spans[0].status.code).toBe(otel.SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe("");
+  });
+
   it("should not set status when no completion action present", () => {
     const tracer = otel.trace.getTracer(TRACER_NAME);
     const span = tracer.startSpan("orch-status-none");

scripts/test-e2e-functions.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+# Script to run the gated Azure Functions host E2E tests.
+#
+# This mirrors scripts/test-e2e-azuremanaged.sh. The suite launches a real
+# Azure Functions host ("func start") for test/e2e-functions/test-app, backed by
+# Azurite (the local Azure Storage emulator), and drives it over HTTP.
+#
+# The test-app depends on the PUBLISHED durable-functions / @azure/functions
+# packages, so it installs and builds without any in-repo package build.
+#
+# Prerequisites (the suite SKIPS cleanly if any are missing):
+#   - Azure Functions Core Tools ('func') v4 on PATH
+#   - Azurite reachable on 127.0.0.1:10000 (started here if the 'azurite' CLI is
+#     installed and the port is free)
+
+set -uo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEST_APP_DIR="$ROOT_DIR/test/e2e-functions/test-app"
+
+AZURITE_HOST="127.0.0.1"
+AZURITE_BLOB_PORT="10000"
+
+started_azurite=""
+
+azurite_up() {
+    (exec 3<>"/dev/tcp/$AZURITE_HOST/$AZURITE_BLOB_PORT") 2>/dev/null && exec 3>&- 3<&-
+}
+
+if ! azurite_up; then
+    if command -v azurite >/dev/null 2>&1; then
+        echo "Starting Azurite..."
+        AZURITE_DATA="$(mktemp -d)"
+        azurite --silent --location "$AZURITE_DATA" \
+            --blobPort 10000 --queuePort 10001 --tablePort 10002 &
+        started_azurite="$!"
+        for _ in $(seq 1 30); do
+            azurite_up && break
+            sleep 1
+        done
+    else
+        echo "Azurite is not running and 'azurite' is not installed; the suite will skip."
+    fi
+fi
+
+# Install + build the ported BasicNode app against the published durable-functions
+# package so 'func start' has a dist/ to serve. If this fails there is no app to
+# run, so fail fast instead of letting the suite skip and masking the error.
+echo "Installing + building test-app..."
+if ! ( cd "$TEST_APP_DIR" && npm install && npm run build ); then
+    echo "test-app install/build failed." >&2
+    if [ -n "$started_azurite" ]; then
+        echo "Stopping Azurite..."
+        kill "$started_azurite" 2>/dev/null || true
+    fi
+    exit 1
+fi
+
+echo "Running Functions host E2E tests..."
+( cd "$ROOT_DIR" && npm run test:e2e:functions:internal )
+status=$?
+
+if [ -n "$started_azurite" ]; then
+    echo "Stopping Azurite..."
+    kill "$started_azurite" 2>/dev/null || true
+fi
+
+exit $status