local integration tests: stay runnable on dd-trace v6 trees

The pack step ran `yarn install --frozen-lockfile` directly. On a tree that
pins dd-trace v6 (engines node >=22) with a host Node older than 22 — e.g.
this repo's GitHub Actions runner image, which sets up Node 18.12 — that
install fails with "The engine \"node\" is incompatible with this module",
so every local integration test leg on a v6 PR fails before any container
is built.

Two changes, both no-ops on the current v5 tree:

- Pack step: when scripts/install_deps.sh exists (v6 world), install
  through it with TARGET_NODE_MAJOR=$RUNTIME_PARAM (default 22) so the v5
  fallback line is installed for older runtimes and --ignore-engines
  covers v6 on older hosts. The script restores package.json/yarn.lock on
  exit, so the worktree stays clean. Without it, fall back to the previous
  plain yarn install.
- Container builds: pass a DD_TRACE_VERSION build-arg resolved through
  scripts/dd_trace_versions.sh (v5 line for node <22) so the fixture image
  installs a tracer its runtime can actually run. Current fixture
  Dockerfiles declare no such ARG, so docker only warns; v6-world fixtures
  consume it via npm pkg set.

Verified:
- v5 tree: RUNTIME_PARAM=22 CASE_PARAM=container-cjs passes end to end.
- v6 tree (onzia/moreddtrace6 + this harness): node18 leg installs
  dd-trace 5.124.0 and node22 leg installs 6.12.0 on a Node 18 host (the
  original failure scenario), containers build and run; the only remaining
  diffs are the expected tracer-version snapshot drift (5.118 -> 5.124/6.x
  drop empty "links": [] and populate dd_trace meta), which the v6 PR owns
  regenerating, same as it already did for the AWS snapshots.

Author: joeyzhao2018

integration_tests_local/README.md

@@ -44,6 +44,13 @@ SKIP_PACK=true RUNTIME_PARAM=18 CASE_PARAM=container-esm ./integration_tests_loc
 PLATFORM=linux/amd64 ./integration_tests_local/run.sh
 ```
 
+On a tree that pins dd-trace v6 (which older runtimes cannot install), the
+pack step installs through `scripts/install_deps.sh` with
+`TARGET_NODE_MAJOR=$RUNTIME_PARAM` and the container fixtures get a matching
+`DD_TRACE_VERSION` build-arg. Run per-runtime there, like CI does: a full
+sweep packs only once, so its layer fixture would carry the first leg's
+tracer line into every other leg.
+
 The case names are:
 
 | Case | What it covers |

integration_tests_local/run.sh

@@ -331,7 +331,20 @@ fi
 if [ -z "$SKIP_PACK" ]; then
     echo "Packing local datadog-lambda-js for container tests"
     cd "$repo_dir"
-    yarn install --frozen-lockfile
+    if [ -f "$repo_dir/scripts/install_deps.sh" ]; then
+        # dd-trace v6 world: the repo pins a tracer whose engines may reject
+        # the host node (e.g. v6 requires node >=22 while CI hosts node 18).
+        # install_deps.sh installs the tracer line matching the target
+        # runtime, rewriting package.json/yarn.lock and restoring them via a
+        # trap on exit, so the worktree is left untouched.
+        # NOTE: in the v6 world a full local sweep packs once with
+        # TARGET_NODE_MAJOR=$RUNTIME_PARAM (default 22); run per-runtime like
+        # CI does (RUNTIME_PARAM=18 ./integration_tests_local/run.sh) so the
+        # layer fixture's pinned dd-trace matches each leg.
+        TARGET_NODE_MAJOR=${RUNTIME_PARAM:-22} "$repo_dir/scripts/install_deps.sh"
+    else
+        yarn install --frozen-lockfile
+    fi
     yarn build
     npm pack
     cp datadog-lambda-js-*.tgz "$integration_tests_dir/container/cjs/datadog-lambda-js-local.tgz"
@@ -488,6 +501,17 @@ function write_snapshot() {
 
 for node_version in "${RUNTIMES[@]}"; do
     node_image_tag=$(lambda_node_image_tag "$node_version")
+    # In the dd-trace v6 world the container fixtures take a DD_TRACE_VERSION
+    # build-arg (fixture package.json pins the newest line, which older
+    # runtimes cannot install). Pin the fixture to the tracer line that
+    # actually supports this runtime. On the v5 world there is no
+    # dd_trace_versions.sh and the fixture Dockerfiles declare no such ARG;
+    # docker only warns about the unused build-arg, so this stays harmless.
+    dd_trace_build_version=""
+    if [ -f "$repo_dir/scripts/dd_trace_versions.sh" ]; then
+        . "$repo_dir/scripts/dd_trace_versions.sh"
+        dd_trace_build_version=$(dd_trace_version_for_node_major "$node_version")
+    fi
     for case_name in "${CASES[@]}"; do
         configure_case "$case_name" || exit 1
         handler_name="$case_name"
@@ -510,6 +534,7 @@ for node_version in "${RUNTIMES[@]}"; do
         echo "=== Building $image_tag from Lambda Node image $node_image_tag (platform $PLATFORM) ==="
         docker build --platform "$PLATFORM" \
             --build-arg NODE_VERSION="$node_image_tag" \
+            --build-arg DD_TRACE_VERSION="$dd_trace_build_version" \
             -t "$image_tag" \
             "$integration_tests_dir/container/$case_image" || exit 1