@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/worker.rs

@@ -10,24 +10,24 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporal_sdk_core::{
-    WorkerConfigBuilder,
-    replay::{HistoryForReplay, ReplayWorkerInput},
-};
-use temporal_sdk_core_api::{
+use temporalio_common::{
     Worker as CoreWorker,
     errors::{PollError, WorkflowErrorType},
+    protos::{
+        coresdk::{
+            ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::history::v1::History,
+    },
     worker::{
         SlotInfoTrait, SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
         SlotSupplierPermit,
     },
 };
-use temporal_sdk_core_protos::{
-    coresdk::{
-        ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::history::v1::History,
+use temporalio_sdk_core::{
+    WorkerConfigBuilder,
+    replay::{HistoryForReplay, ReplayWorkerInput},
 };
 use tokio::sync::{
     Notify,
@@ -43,7 +43,7 @@ pub struct WorkerOptions {
     pub identity_override: ByteArrayRef,
     pub max_cached_workflows: u32,
     pub tuner: TunerHolder,
-    pub no_remote_activities: bool,
+    pub task_types: WorkerTaskTypes,
     pub sticky_queue_schedule_to_start_timeout_millis: u64,
     pub max_heartbeat_throttle_interval_millis: u64,
     pub default_heartbeat_throttle_interval_millis: u64,
@@ -56,6 +56,26 @@ pub struct WorkerOptions {
     pub nexus_task_poller_behavior: PollerBehavior,
     pub nondeterminism_as_workflow_fail: bool,
     pub nondeterminism_as_workflow_fail_for_types: ByteArrayRefArray,
+    pub plugins: ByteArrayRefArray,
+}
+
+#[repr(C)]
+pub struct WorkerTaskTypes {
+    pub enable_workflows: bool,
+    pub enable_local_activities: bool,
+    pub enable_remote_activities: bool,
+    pub enable_nexus: bool,
+}
+
+impl From<&WorkerTaskTypes> for temporalio_common::worker::WorkerTaskTypes {
+    fn from(t: &WorkerTaskTypes) -> Self {
+        Self {
+            enable_workflows: t.enable_workflows,
+            enable_local_activities: t.enable_local_activities,
+            enable_remote_activities: t.enable_remote_activities,
+            enable_nexus: t.enable_nexus,
+        }
+    }
 }
 
 #[repr(C)]
@@ -77,18 +97,18 @@ pub struct PollerBehavior {
     pub autoscaling: *const PollerBehaviorAutoscaling,
 }
 
-impl TryFrom<&PollerBehavior> for temporal_sdk_core_api::worker::PollerBehavior {
+impl TryFrom<&PollerBehavior> for temporalio_common::worker::PollerBehavior {
     type Error = anyhow::Error;
     fn try_from(value: &PollerBehavior) -> Result<Self, Self::Error> {
         if !value.simple_maximum.is_null() && !value.autoscaling.is_null() {
             bail!("simple_maximum and autoscaling cannot both be non-null values");
         }
         if let Some(value) = unsafe { value.simple_maximum.as_ref() } {
-            return Ok(
-                temporal_sdk_core_api::worker::PollerBehavior::SimpleMaximum(value.simple_maximum),
-            );
+            return Ok(temporalio_common::worker::PollerBehavior::SimpleMaximum(
+                value.simple_maximum,
+            ));
         } else if let Some(value) = unsafe { value.autoscaling.as_ref() } {
-            return Ok(temporal_sdk_core_api::worker::PollerBehavior::Autoscaling {
+            return Ok(temporalio_common::worker::PollerBehavior::Autoscaling {
                 minimum: value.minimum,
                 maximum: value.maximum,
                 initial: value.initial,
@@ -217,7 +237,7 @@ pub struct CustomSlotSupplierCallbacks {
     /// is arbitrary, but must be unique among live reservations as it's later used for [`mark_used`](Self::mark_used)
     /// and [`release`](Self::release) callbacks.
     pub try_reserve: CustomSlotSupplierTryReserveCallback,
-    /// Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporal_sdk_core_api::worker::SlotSupplier)
+    /// Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporalio_common::worker::SlotSupplier)
     /// trait for details.
     pub mark_used: CustomSlotSupplierMarkUsedCallback,
     /// Called to free a previously reserved slot.
@@ -238,7 +258,7 @@ pub struct CustomSlotSupplierCallbacks {
 impl CustomSlotSupplierCallbacksImpl {
     fn into_ss<SK: SlotKind + Send + Sync + 'static>(
         self,
-    ) -> Arc<dyn temporal_sdk_core_api::worker::SlotSupplier<SlotKind = SK> + Send + Sync + 'static>
+    ) -> Arc<dyn temporalio_common::worker::SlotSupplier<SlotKind = SK> + Send + Sync + 'static>
     {
         Arc::new(CustomSlotSupplier {
             inner: self,
@@ -356,7 +376,7 @@ impl<'a, SK: SlotKind + Send + Sync> Drop for CancelReserveGuard<'a, SK> {
 }
 
 #[async_trait::async_trait]
-impl<SK: SlotKind + Send + Sync> temporal_sdk_core_api::worker::SlotSupplier
+impl<SK: SlotKind + Send + Sync> temporalio_common::worker::SlotSupplier
     for CustomSlotSupplier<SK>
 {
     type SlotKind = SK;
@@ -447,18 +467,16 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
     fn convert_reserve_ctx(ctx: &dyn SlotReservationContext) -> SlotReserveCtx {
         SlotReserveCtx {
             slot_type: match SK::kind() {
-                temporal_sdk_core_api::worker::SlotKindType::Workflow => {
+                temporalio_common::worker::SlotKindType::Workflow => {
                     SlotKindType::WorkflowSlotKindType
                 }
-                temporal_sdk_core_api::worker::SlotKindType::Activity => {
+                temporalio_common::worker::SlotKindType::Activity => {
                     SlotKindType::ActivitySlotKindType
                 }
-                temporal_sdk_core_api::worker::SlotKindType::LocalActivity => {
+                temporalio_common::worker::SlotKindType::LocalActivity => {
                     SlotKindType::LocalActivitySlotKindType
                 }
-                temporal_sdk_core_api::worker::SlotKindType::Nexus => {
-                    SlotKindType::NexusSlotKindType
-                }
+                temporalio_common::worker::SlotKindType::Nexus => SlotKindType::NexusSlotKindType,
             },
             task_queue: ctx.task_queue().into(),
             worker_identity: ctx.worker_identity().into(),
@@ -471,21 +489,21 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
         }
     }
 
-    fn convert_slot_info(info: temporal_sdk_core_api::worker::SlotInfo) -> SlotInfo {
+    fn convert_slot_info(info: temporalio_common::worker::SlotInfo) -> SlotInfo {
         match info {
-            temporal_sdk_core_api::worker::SlotInfo::Workflow(w) => SlotInfo::WorkflowSlotInfo {
+            temporalio_common::worker::SlotInfo::Workflow(w) => SlotInfo::WorkflowSlotInfo {
                 workflow_type: w.workflow_type.as_str().into(),
                 is_sticky: w.is_sticky,
             },
-            temporal_sdk_core_api::worker::SlotInfo::Activity(a) => SlotInfo::ActivitySlotInfo {
+            temporalio_common::worker::SlotInfo::Activity(a) => SlotInfo::ActivitySlotInfo {
                 activity_type: a.activity_type.as_str().into(),
             },
-            temporal_sdk_core_api::worker::SlotInfo::LocalActivity(a) => {
+            temporalio_common::worker::SlotInfo::LocalActivity(a) => {
                 SlotInfo::LocalActivitySlotInfo {
                     activity_type: a.activity_type.as_str().into(),
                 }
             }
-            temporal_sdk_core_api::worker::SlotInfo::Nexus(n) => SlotInfo::NexusSlotInfo {
+            temporalio_common::worker::SlotInfo::Nexus(n) => SlotInfo::NexusSlotInfo {
                 operation: n.operation.as_str().into(),
                 service: n.service.as_str().into(),
             },
@@ -502,7 +520,7 @@ pub struct ResourceBasedTunerOptions {
 
 #[derive(Clone)]
 pub struct Worker {
-    worker: Option<Arc<temporal_sdk_core::Worker>>,
+    worker: Option<Arc<temporalio_sdk_core::Worker>>,
     runtime: Runtime,
 }
 
@@ -561,7 +579,7 @@ pub extern "C" fn temporal_core_worker_new(
                 .into_raw()
                 .cast_const(),
         ),
-        Ok(config) => match temporal_sdk_core::init_worker(
+        Ok(config) => match temporalio_sdk_core::init_worker(
             &client.runtime.core,
             config,
             client.core.clone().into_inner(),
@@ -629,11 +647,21 @@ pub extern "C" fn temporal_core_worker_validate(
 pub extern "C" fn temporal_core_worker_replace_client(
     worker: *mut Worker,
     new_client: *mut Client,
-) {
+) -> *const ByteArray {
     let worker = unsafe { &*worker };
+    enter_sync!(worker.runtime);
     let core_worker = worker.worker.as_ref().expect("missing worker").clone();
     let client = unsafe { &*new_client };
-    core_worker.replace_client(client.core.get_client().clone());
+
+    match core_worker.replace_client(client.core.get_client().clone()) {
+        Ok(()) => std::ptr::null(),
+        Err(err) => worker
+            .runtime
+            .clone()
+            .alloc_utf8(&format!("Replace client failed: {err}"))
+            .into_raw()
+            .cast_const(),
+    }
 }
 
 /// If success or fail are present, they must be freed. They will both be null
@@ -974,7 +1002,7 @@ pub extern "C" fn temporal_core_worker_replayer_new(
         ),
         Ok(config) => {
             let (tx, rx) = channel(1);
-            match temporal_sdk_core::init_replay_worker(ReplayWorkerInput::new(
+            match temporalio_sdk_core::init_replay_worker(ReplayWorkerInput::new(
                 config,
                 ReceiverStream::new(rx),
             )) {
@@ -1131,18 +1159,18 @@ pub extern "C" fn temporal_core_complete_async_cancel_reserve(
     }
 }
 
-impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
+impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
     type Error = anyhow::Error;
 
     fn try_from(opt: &WorkerOptions) -> anyhow::Result<Self> {
-        let converted_tuner: temporal_sdk_core::TunerHolder = (&opt.tuner).try_into()?;
+        let converted_tuner: temporalio_sdk_core::TunerHolder = (&opt.tuner).try_into()?;
         WorkerConfigBuilder::default()
             .namespace(opt.namespace.to_str())
             .task_queue(opt.task_queue.to_str())
             .versioning_strategy({
                 match &opt.versioning_strategy {
                     WorkerVersioningStrategy::None(n) => {
-                        temporal_sdk_core_api::worker::WorkerVersioningStrategy::None {
+                        temporalio_common::worker::WorkerVersioningStrategy::None {
                             build_id: n.build_id.to_string(),
                         }
                     }
@@ -1150,21 +1178,24 @@ impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
                         let dvb = if let Ok(v) = dopts.default_versioning_behavior.try_into() {
                             Some(v)
                         } else {
-                            bail!("Invalid default versioning behavior {}", dopts.default_versioning_behavior)
+                            bail!(
+                                "Invalid default versioning behavior {}",
+                                dopts.default_versioning_behavior
+                            )
                         };
-                        temporal_sdk_core_api::worker::WorkerVersioningStrategy::WorkerDeploymentBased(
-                            temporal_sdk_core_api::worker::WorkerDeploymentOptions {
-                                version: temporal_sdk_core_api::worker::WorkerDeploymentVersion {
+                        temporalio_common::worker::WorkerVersioningStrategy::WorkerDeploymentBased(
+                            temporalio_common::worker::WorkerDeploymentOptions {
+                                version: temporalio_common::worker::WorkerDeploymentVersion {
                                     deployment_name: dopts.version.deployment_name.to_string(),
                                     build_id: dopts.version.build_id.to_string(),
                                 },
                                 use_worker_versioning: dopts.use_worker_versioning,
                                 default_versioning_behavior: dvb,
-                            }
+                            },
                         )
                     }
                     WorkerVersioningStrategy::LegacyBuildIdBased(l) => {
-                        temporal_sdk_core_api::worker::WorkerVersioningStrategy::LegacyBuildIdBased {
+                        temporalio_common::worker::WorkerVersioningStrategy::LegacyBuildIdBased {
                             build_id: l.build_id.to_string(),
                         }
                     }
@@ -1173,7 +1204,9 @@ impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
             .client_identity_override(opt.identity_override.to_option_string())
             .max_cached_workflows(opt.max_cached_workflows as usize)
             .tuner(Arc::new(converted_tuner))
-            .no_remote_activities(opt.no_remote_activities)
+            .task_types(temporalio_common::worker::WorkerTaskTypes::from(
+                &opt.task_types,
+            ))
             .sticky_queue_schedule_to_start_timeout(Duration::from_millis(
                 opt.sticky_queue_schedule_to_start_timeout_millis,
             ))
@@ -1199,10 +1232,16 @@ impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
             // auto-cancel-activity behavior or shutdown will not occur, so we
             // always set it even if 0.
             .graceful_shutdown_period(Duration::from_millis(opt.graceful_shutdown_period_millis))
-            .workflow_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.workflow_task_poller_behavior)?)
+            .workflow_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+                &opt.workflow_task_poller_behavior,
+            )?)
             .nonsticky_to_sticky_poll_ratio(opt.nonsticky_to_sticky_poll_ratio)
-            .activity_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.activity_task_poller_behavior)?)
-            .nexus_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.nexus_task_poller_behavior)?)
+            .activity_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+                &opt.activity_task_poller_behavior,
+            )?)
+            .nexus_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+                &opt.nexus_task_poller_behavior,
+            )?)
             .workflow_failure_errors(if opt.nondeterminism_as_workflow_fail {
                 HashSet::from([WorkflowErrorType::Nondeterminism])
             } else {
@@ -1220,12 +1259,26 @@ impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
                     })
                     .collect::<HashMap<String, HashSet<WorkflowErrorType>>>(),
             )
+            .plugins(
+                opt.plugins
+                    .to_str_vec()
+                    .into_iter()
+                    .collect::<HashSet<_>>()
+                    .into_iter()
+                    .map(
+                        |name| temporalio_common::protos::temporal::api::worker::v1::PluginInfo {
+                            name: name.to_owned(),
+                            version: String::new(),
+                        },
+                    )
+                    .collect::<HashSet<_>>(),
+            )
             .build()
             .map_err(|err| anyhow::anyhow!(err))
     }
 }
 
-impl TryFrom<&TunerHolder> for temporal_sdk_core::TunerHolder {
+impl TryFrom<&TunerHolder> for temporalio_sdk_core::TunerHolder {
     type Error = anyhow::Error;
 
     fn try_from(holder: &TunerHolder) -> anyhow::Result<Self> {
@@ -1271,10 +1324,10 @@ impl TryFrom<&TunerHolder> for temporal_sdk_core::TunerHolder {
             bail!("All resource-based slot suppliers must have the same ResourceBasedTunerOptions",);
         }
 
-        let mut options = temporal_sdk_core::TunerHolderOptionsBuilder::default();
+        let mut options = temporalio_sdk_core::TunerHolderOptionsBuilder::default();
         if let Some(first) = first {
             options.resource_based_options(
-                temporal_sdk_core::ResourceBasedSlotsOptionsBuilder::default()
+                temporalio_sdk_core::ResourceBasedSlotsOptionsBuilder::default()
                     .target_mem_usage(first.target_memory_usage)
                     .target_cpu_usage(first.target_cpu_usage)
                     .build()
@@ -1294,20 +1347,20 @@ impl TryFrom<&TunerHolder> for temporal_sdk_core::TunerHolder {
 }
 
 impl<SK: SlotKind + Send + Sync + 'static> TryFrom<SlotSupplier>
-    for temporal_sdk_core::SlotSupplierOptions<SK>
+    for temporalio_sdk_core::SlotSupplierOptions<SK>
 {
     type Error = anyhow::Error;
 
     fn try_from(
         supplier: SlotSupplier,
-    ) -> anyhow::Result<temporal_sdk_core::SlotSupplierOptions<SK>> {
+    ) -> anyhow::Result<temporalio_sdk_core::SlotSupplierOptions<SK>> {
         Ok(match supplier {
-            SlotSupplier::FixedSize(fs) => temporal_sdk_core::SlotSupplierOptions::FixedSize {
+            SlotSupplier::FixedSize(fs) => temporalio_sdk_core::SlotSupplierOptions::FixedSize {
                 slots: fs.num_slots,
             },
             SlotSupplier::ResourceBased(ss) => {
-                temporal_sdk_core::SlotSupplierOptions::ResourceBased(
-                    temporal_sdk_core::ResourceSlotOptions::new(
+                temporalio_sdk_core::SlotSupplierOptions::ResourceBased(
+                    temporalio_sdk_core::ResourceSlotOptions::new(
                         ss.minimum_slots,
                         ss.maximum_slots,
                         Duration::from_millis(ss.ramp_throttle_ms),
@@ -1315,7 +1368,7 @@ impl<SK: SlotKind + Send + Sync + 'static> TryFrom<SlotSupplier>
                 )
             }
             SlotSupplier::Custom(cs) => {
-                temporal_sdk_core::SlotSupplierOptions::Custom(cs.into_ss())
+                temporalio_sdk_core::SlotSupplierOptions::Custom(cs.into_ss())
             }
         })
     }

package/sdk-core/docker-cgroup-tests.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+# Runs tests in a constrained Docker cgroup by cross-compiling them to MUSL with
+# `cargo zigbuild` and executing inside Ubuntu.
+# Requirements:
+# - Zig toolchain: https://ziglang.org/download/
+# - cargo-zigbuild helper: https://github.com/rust-cross/cargo-zigbuild#installation (e.g. `cargo install cargo-zigbuild`)
+
+# Usage:
+#   ./docker-cgroup-tests.sh [cpus] [memory]
+# Defaults:
+#   cpus   = 0.1  (limit available CPU cores)
+#   memory = 256m (limit available RAM)
+
+# cross-compiles integration tests with cargo zigbuild, then runs them using docker
+executable_path=$(cargo zigbuild --target x86_64-unknown-linux-musl --tests --features="test-utilities ephemeral-server" --message-format=json | jq -r 'select(.profile?.test == true and .target?.name == "temporalio_sdk_core" and .executable) | .executable')
+relative_path="target/${executable_path#*target/}"
+
+cpus="${1:-0.1}"
+memory="${2:-256m}"
+
+printf 'Running with cpus=%s memory=%s\n' "$cpus" "$memory"
+
+docker run --rm -v "$PWD":/app -w /app --cpus="$cpus" --memory="$memory" --env CGROUP_TESTS_ENABLED=true ubuntu bash -c "./$relative_path cgroup_ --nocapture"

package/sdk-core/{docker → etc/docker}/docker-compose-ci.yaml

@@ -1,25 +1,25 @@
-version: '3.5'
+version: "3.5"
 
 services:
   otel-collector:
     image: otel/opentelemetry-collector:latest
-    command: [ '--config=/etc/otel-collector-ci.yaml' ]
+    command: ["--config=/etc/otel-collector-ci.yaml"]
     volumes:
-      - ../etc/otel-collector-ci.yaml:/etc/otel-collector-ci.yaml
+      - ../otel-collector-ci.yaml:/etc/otel-collector-ci.yaml
     ports:
       #      - "1888:1888"   # pprof extension
       # It's useful to be able to manually inspect metrics during dev
-      - '8888:8888' # Prometheus metrics exposed by the collector
-      - '8889:8889' # Prometheus exporter metrics
+      - "8888:8888" # Prometheus metrics exposed by the collector
+      - "8889:8889" # Prometheus exporter metrics
       #      - "13133:13133" # health_check extension
-      - '4317:4317' # OTLP gRPC receiver
-      - '4318:4318' # OTLP HTTP receiver
+      - "4317:4317" # OTLP gRPC receiver
+      - "4318:4318" # OTLP HTTP receiver
     #      - "55679:55679" # zpages extension
 
   prometheus:
     container_name: prometheus
     image: prom/prometheus:latest
     volumes:
-      - ../etc/prometheus.yaml:/etc/prometheus/prometheus.yml
+      - ../prometheus.yaml:/etc/prometheus/prometheus.yml
     ports:
-      - '9090:9090'
+      - "9090:9090"

package/sdk-core/{docker → etc/docker}/docker-compose-telem.yaml

@@ -1,25 +1,25 @@
-version: '3.5'
+version: "3.5"
 
 services:
   jaeger:
     image: jaegertracing/all-in-one:latest
     ports:
-      - '16686:16686'
-      - '14268'
-      - '14250'
+      - "16686:16686"
+      - "14268"
+      - "14250"
 
   otel-collector:
     image: otel/opentelemetry-collector:latest
-    command: [ '--config=/etc/otel-collector-config.yaml' ]
+    command: ["--config=/etc/otel-collector-config.yaml"]
     volumes:
-      - ../etc/otel-collector-config.yaml:/etc/otel-collector-config.yaml
+      - ../otel-collector-config.yaml:/etc/otel-collector-config.yaml
     ports:
       #      - "1888:1888"   # pprof extension
       # It's useful to be able to manually inspect metrics during dev
-      - '8888:8888' # Prometheus metrics exposed by the collector
-      - '8889:8889' # Prometheus exporter metrics
+      - "8888:8888" # Prometheus metrics exposed by the collector
+      - "8889:8889" # Prometheus exporter metrics
       #      - "13133:13133" # health_check extension
-      - '4317:4317' # OTLP gRPC receiver
+      - "4317:4317" # OTLP gRPC receiver
     #      - "55679:55679" # zpages extension
     depends_on:
       - jaeger
@@ -29,6 +29,6 @@ services:
     container_name: prometheus
     image: prom/prometheus:latest
     volumes:
-      - ../etc/prometheus.yaml:/etc/prometheus/prometheus.yml
+      - ../prometheus.yaml:/etc/prometheus/prometheus.yml
     ports:
-      - '9090:9090'
+      - "9090:9090"

package/sdk-core/{docker → etc/docker}/docker-compose.yaml

@@ -1,4 +1,4 @@
-version: '3.5'
+version: "3.5"
 
 services:
   cassandra:
@@ -13,17 +13,17 @@ services:
     ports:
       - "7233:7233"
       - "7234:7234"
-#      - "7235:7235"
-#      - "7239:7239"
-#      - "6933:6933"
-#      - "6934:6934"
-#      - "6935:6935"
-#      - "6939:6939"
+    #      - "7235:7235"
+    #      - "7239:7239"
+    #      - "6933:6933"
+    #      - "6934:6934"
+    #      - "6935:6935"
+    #      - "6939:6939"
     environment:
       - "CASSANDRA_SEEDS=cassandra"
       - "DYNAMIC_CONFIG_FILE_PATH=/etc/dynamic-config.yaml"
     volumes:
-      - ../../etc/dynamic-config.yaml:/etc/dynamic-config.yaml
+      - ../dynamic-config.yaml:/etc/dynamic-config.yaml
     depends_on:
       - cassandra
 

package/sdk-core/{integ-with-otel.sh → etc/integ-with-otel.sh}

@@ -2,6 +2,6 @@
 
 # Run integ tests with OTel collector export enabled
 export TEMPORAL_INTEG_OTEL_URL="grpc://localhost:4317"
-export TEMPORAL_TRACING_FILTER="temporal_sdk_core=DEBUG"
+export TEMPORAL_TRACING_FILTER="temporalio_sdk_core=DEBUG"
 
 cargo integ-test "${@:1}"

package/sdk-core/etc/regen-depgraph.sh

@@ -1,5 +1,5 @@
 # Run this from the repo root
 cargo depgraph \
-  --focus temporal-sdk,temporal-sdk-core-protos,temporal-client,temporal-sdk-core-api,temporal-sdk-core,rustfsm \
+  --focus temporalio-sdk,temporalio-common,temporalio-client,temporalio-sdk-core,temporalio-macros,temporalio-sdk-core-c-bridge \
   --dev-deps \
-  | dot -Tsvg > etc/deps.svg
+  | dot -Tsvg > arch_docs/diagrams/deps.svg