@temporalio/core-bridge 1.11.1 → 1.11.3

package/sdk-core/core/src/worker/workflow/machines/activity_state_machine.rs

@@ -90,13 +90,13 @@ fsm! {
 
 #[derive(Debug, derive_more::Display)]
 pub(super) enum ActivityMachineCommand {
-    #[display(fmt = "Complete")]
+    #[display("Complete")]
     Complete(Option<Payloads>),
-    #[display(fmt = "Fail")]
+    #[display("Fail")]
     Fail(Failure),
-    #[display(fmt = "Cancel")]
+    #[display("Cancel")]
     Cancel(Option<ActivityTaskCanceledEventAttributes>),
-    #[display(fmt = "RequestCancellation")]
+    #[display("RequestCancellation")]
     RequestCancellation(Command),
 }
 
@@ -166,6 +166,7 @@ impl ActivityMachine {
                     failure: Some(new_cancel_failure(&self.shared_state, attrs)),
                 })),
             }),
+            is_local: false,
         }
     }
 }
@@ -265,6 +266,7 @@ impl WFMachinesAdapter for ActivityMachine {
                             result: convert_payloads(event_info, result)?,
                         })),
                     }),
+                    is_local: false,
                 }
                 .into()]
             }
@@ -276,6 +278,7 @@ impl WFMachinesAdapter for ActivityMachine {
                             failure: Some(failure),
                         })),
                     }),
+                    is_local: false,
                 }
                 .into()]
             }
@@ -838,7 +841,7 @@ mod test {
             assert_matches!(
                 a.jobs.as_slice(),
                 [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+                    variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 }]
             )
         });

package/sdk-core/core/src/worker/workflow/machines/cancel_external_state_machine.rs

@@ -51,7 +51,7 @@ pub(super) struct SharedState {
 pub(super) enum CancelExternalCommand {
     /// The target workflow has been notified of the cancel
     Requested,
-    #[display(fmt = "Failed")]
+    #[display("Failed")]
     Failed(CancelExternalWorkflowExecutionFailedCause),
 }
 

package/sdk-core/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs

@@ -133,7 +133,7 @@ mod tests {
             assert_matches!(
                 a.jobs.as_slice(),
                 [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+                    variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 }]
             )
         });

package/sdk-core/core/src/worker/workflow/machines/child_workflow_state_machine.rs

@@ -105,19 +105,19 @@ pub(super) struct ChildWorkflowExecutionStartedEvent {
 
 #[derive(Debug, derive_more::Display)]
 pub(super) enum ChildWorkflowCommand {
-    #[display(fmt = "Start")]
+    #[display("Start")]
     Start(WorkflowExecution),
-    #[display(fmt = "Complete")]
+    #[display("Complete")]
     Complete(Option<Payloads>),
-    #[display(fmt = "Fail")]
+    #[display("Fail")]
     Fail(Failure),
-    #[display(fmt = "Cancel")]
+    #[display("Cancel")]
     Cancel,
-    #[display(fmt = "StartFail")]
+    #[display("StartFail")]
     StartFail(StartChildWorkflowExecutionFailedCause),
-    #[display(fmt = "StartCancel")]
+    #[display("StartCancel")]
     StartCancel(Failure),
-    #[display(fmt = "CancelAfterStarted")]
+    #[display("CancelAfterStarted")]
     IssueCancelAfterStarted { reason: String },
 }
 

package/sdk-core/core/src/worker/workflow/machines/local_activity_state_machine.rs

@@ -8,7 +8,7 @@ use crate::{
     worker::{
         workflow::{
             machines::{activity_state_machine::activity_fail_info, HistEventData},
-            InternalFlagsRef, OutgoingJob,
+            InternalFlagsRef,
         },
         LocalActivityExecutionResult,
     },
@@ -342,17 +342,17 @@ impl SharedState {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum LocalActivityCommand {
     RequestActivityExecution(ValidScheduleLA),
-    #[display(fmt = "Resolved")]
+    #[display("Resolved")]
     Resolved(ResolveDat),
     /// The fake marker is used to avoid special casing marker recorded event handling.
     /// If we didn't have the fake marker, there would be no "outgoing command" to match
     /// against the event. This way there is, but the command never will be issued to
     /// server because it is understood to be meaningless.
-    #[display(fmt = "FakeMarker")]
+    #[display("FakeMarker")]
     FakeMarker,
     /// Indicate we want to cancel an LA that is currently executing, or look up if we have
     /// processed a marker with resolution data since the machine was constructed.
-    #[display(fmt = "Cancel")]
+    #[display("Cancel")]
     RequestCancel,
 }
 
@@ -631,9 +631,6 @@ impl Cancellable for LocalActivityMachine {
     }
 }
 
-#[derive(Default, Clone)]
-pub(super) struct Abandoned {}
-
 impl WFMachinesAdapter for LocalActivityMachine {
     fn adapt_response(
         &self,
@@ -737,14 +734,12 @@ impl WFMachinesAdapter for LocalActivityMachine {
                 };
 
                 let mut responses = vec![
-                    MachineResponse::PushWFJob(OutgoingJob {
-                        variant: ResolveActivity {
-                            seq: self.shared_state.attrs.seq,
-                            result: Some(resolution),
-                        }
-                        .into(),
-                        is_la_resolution: true,
-                    }),
+                    ResolveActivity {
+                        seq: self.shared_state.attrs.seq,
+                        result: Some(resolution),
+                        is_local: true,
+                    }
+                    .into(),
                     MachineResponse::UpdateWFTime(complete_time),
                 ];
 

package/sdk-core/core/src/worker/workflow/machines/mod.rs

@@ -236,7 +236,7 @@ trait WFMachinesAdapter: StateMachine {
 /// Wraps a history event with extra relevant data that a machine might care about while the event
 /// is being applied to it.
 #[derive(Debug, derive_more::Display)]
-#[display(fmt = "{event}")]
+#[display("{event}")]
 struct HistEventData {
     event: HistoryEvent,
     /// Is the current workflow task under replay or not during application of this event?

package/sdk-core/core/src/worker/workflow/machines/patch_state_machine.rs

@@ -551,10 +551,11 @@ mod tests {
 
         let mut aai = ActivationAssertionsInterceptor::default();
         aai.then(move |act| {
-            // replaying cases should immediately get a resolve change activation when marker is present
+            // replaying cases should immediately get a resolve change activation when marker is
+            // present
             if replaying && marker_type != MarkerType::NoMarker {
                 assert_matches!(
-                    &act.jobs[0],
+                    &act.jobs[1],
                      WorkflowActivationJob {
                         variant: Some(workflow_activation_job::Variant::NotifyHasPatch(
                             NotifyHasPatch {

package/sdk-core/core/src/worker/workflow/machines/signal_external_state_machine.rs

@@ -60,7 +60,7 @@ pub(super) struct SharedState {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum SignalExternalCommand {
     Signaled,
-    #[display(fmt = "Failed")]
+    #[display("Failed")]
     Failed(SignalExternalWorkflowExecutionFailedCause),
     Cancelled,
 }

package/sdk-core/core/src/worker/workflow/machines/update_state_machine.rs

@@ -59,13 +59,13 @@ fsm! {
 
 #[derive(Debug, derive_more::Display)]
 pub(super) enum UpdateMachineCommand {
-    #[display(fmt = "Accept")]
+    #[display("Accept")]
     Accept(update::v1::Request),
-    #[display(fmt = "Reject")]
+    #[display("Reject")]
     Reject(update::v1::Request, Failure),
-    #[display(fmt = "Complete")]
+    #[display("Complete")]
     Complete(Payload),
-    #[display(fmt = "Fail")]
+    #[display("Fail")]
     Fail(Failure),
 }
 

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -163,7 +163,7 @@ pub(crate) struct WorkflowMachines {
 }
 
 #[derive(Debug, derive_more::Display)]
-#[display(fmt = "Cmd&Machine({command})")]
+#[display("Cmd&Machine({command})")]
 struct CommandAndMachine {
     command: MachineAssociatedCommand,
     machine: MachineKey,
@@ -172,7 +172,7 @@ struct CommandAndMachine {
 #[derive(Debug, derive_more::Display)]
 enum MachineAssociatedCommand {
     Real(Box<ProtoCommand>),
-    #[display(fmt = "FakeLocalActivityMarker({_0})")]
+    #[display("FakeLocalActivityMarker({_0})")]
     FakeLocalActivityMarker(u32),
 }
 
@@ -186,7 +186,7 @@ struct ChangeInfo {
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub(super) enum MachineResponse {
-    #[display(fmt = "PushWFJob({_0})")]
+    #[display("PushWFJob({_0})")]
     PushWFJob(OutgoingJob),
 
     /// Pushes a new command into the list that will be sent to server once we respond with the
@@ -198,31 +198,31 @@ pub(super) enum MachineResponse {
     /// The machine requests the creation of another *different* machine. This acts as if lang
     /// had replied to the activation with a command, but we use a special set of IDs to avoid
     /// collisions.
-    #[display(fmt = "NewCoreOriginatedCommand({_0:?})")]
+    #[display("NewCoreOriginatedCommand({_0:?})")]
     NewCoreOriginatedCommand(ProtoCmdAttrs),
-    #[display(fmt = "IssueFakeLocalActivityMarker({_0})")]
+    #[display("IssueFakeLocalActivityMarker({_0})")]
     IssueFakeLocalActivityMarker(u32),
-    #[display(fmt = "TriggerWFTaskStarted")]
+    #[display("TriggerWFTaskStarted")]
     TriggerWFTaskStarted {
         task_started_event_id: i64,
         time: SystemTime,
     },
-    #[display(fmt = "UpdateRunIdOnWorkflowReset({run_id})")]
+    #[display("UpdateRunIdOnWorkflowReset({run_id})")]
     UpdateRunIdOnWorkflowReset { run_id: String },
 
     /// Queue a local activity to be processed by the worker
-    #[display(fmt = "QueueLocalActivity")]
+    #[display("QueueLocalActivity")]
     QueueLocalActivity(ValidScheduleLA),
     /// Request cancellation of an executing local activity
-    #[display(fmt = "RequestCancelLocalActivity({_0})")]
+    #[display("RequestCancelLocalActivity({_0})")]
     RequestCancelLocalActivity(u32),
     /// Indicates we are abandoning the indicated LA, so we can remove it from "outstanding" LAs
     /// and we will not try to WFT heartbeat because of it.
-    #[display(fmt = "AbandonLocalActivity({_0:?})")]
+    #[display("AbandonLocalActivity({_0:?})")]
     AbandonLocalActivity(u32),
 
     /// Set the workflow time to the provided time
-    #[display(fmt = "UpdateWFTime({_0:?})")]
+    #[display("UpdateWFTime({_0:?})")]
     UpdateWFTime(Option<SystemTime>),
 }
 
@@ -449,7 +449,7 @@ impl WorkflowMachines {
         self.drive_me
             .peek_pending_jobs()
             .iter()
-            .any(|v| v.is_la_resolution)
+            .any(|v| v.variant.is_local_activity_resolution())
     }
 
     pub(crate) fn get_metadata_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
@@ -701,7 +701,16 @@ impl WorkflowMachines {
         }
         let mut delayed_actions = vec![];
         // Scan through to the next WFT, searching for any patch / la markers, so that we can
-        // pre-resolve them.
+        // pre-resolve them. This lookahead is necessary because we need these things to be already
+        // resolved in the same activations they would have been resolved in during initial
+        // execution. For example: If a workflow asks to run an LA and then waits on it, we will
+        // write the completion marker at the end of that WFT (as a command). So, upon replay,
+        // we need to lookahead and see that that LA is in fact resolved, so that we don't decide
+        // to execute it anew when lang says it wants to run it.
+        //
+        // Alternatively, lookahead can seemingly be avoided if we were to consider the commands
+        // that follow a WFT to be _part of_ that wft rather than the next one. That change might
+        // make sense to do, and maybe simplifies things slightly, but is a substantial alteration.
         for e in self
             .last_history_from_server
             .peek_next_wft_sequence(last_handled_wft_started_id)
@@ -1152,6 +1161,9 @@ impl WorkflowMachines {
                         );
                     }
                     ProtoCmdAttrs::UpsertWorkflowSearchAttributesCommandAttributes(attrs) => {
+                        // We explicitly do not update the workflows current SAs here since
+                        // core-generated upserts aren't meant to be modified or used within
+                        // workflows by users (but rather, just for them to search with).
                         self.add_cmd_to_wf_task(
                             upsert_search_attrs_internal(attrs),
                             CommandIdKind::NeverResolves,
@@ -1262,6 +1274,8 @@ impl WorkflowMachines {
                     self.add_cmd_to_wf_task(new_timer(attrs), CommandID::Timer(seq).into());
                 }
                 WFCommand::UpsertSearchAttributes(attrs) => {
+                    self.drive_me
+                        .search_attributes_update(attrs.search_attributes.clone());
                     self.add_cmd_to_wf_task(
                         upsert_search_attrs(
                             attrs,
@@ -1538,17 +1552,13 @@ impl WorkflowMachines {
                     .map(Into::into)
                     .unwrap_or_default();
             }
-            if attrs.search_attributes.is_empty() {
-                attrs.search_attributes = started_info
-                    .search_attrs
-                    .clone()
-                    .map(Into::into)
-                    .unwrap_or_default();
-            }
             if attrs.retry_policy.is_none() {
                 attrs.retry_policy.clone_from(&started_info.retry_policy);
             }
         }
+        if attrs.search_attributes.is_empty() {
+            attrs.search_attributes = self.drive_me.get_current_search_attributes();
+        }
         attrs
     }
 

package/sdk-core/core/src/worker/workflow/machines/workflow_task_state_machine.rs

@@ -44,12 +44,12 @@ impl WorkflowTaskMachine {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum WFTaskMachineCommand {
     /// Issued to (possibly) trigger the event loop
-    #[display(fmt = "WFTaskStartedTrigger")]
+    #[display("WFTaskStartedTrigger")]
     WFTaskStartedTrigger {
         task_started_event_id: i64,
         time: SystemTime,
     },
-    #[display(fmt = "RunIdOnWorkflowResetUpdate({run_id})")]
+    #[display("RunIdOnWorkflowResetUpdate({run_id})")]
     RunIdOnWorkflowResetUpdate { run_id: String },
 }
 

package/sdk-core/core/src/worker/workflow/managed_run.rs

@@ -52,9 +52,9 @@ pub(super) type RunUpdateAct = Option<ActivationOrAuto>;
 
 /// Manages access to a specific workflow run. Everything inside is entirely synchronous and should
 /// remain that way.
-#[derive(derive_more::DebugCustom)]
+#[derive(derive_more::Debug)]
 #[debug(
-    fmt = "ManagedRun {{ wft: {:?}, activation: {:?}, task_buffer: {:?} \
+    "ManagedRun {{ wft: {:?}, activation: {:?}, task_buffer: {:?} \
            trying_to_evict: {} }}",
     wft,
     activation,
@@ -562,6 +562,7 @@ impl ManagedRun {
                 reason,
                 EvictionReason::Unspecified | EvictionReason::PaginationOrHistoryFetch
             );
+
         let (should_report, rur) = if is_no_report_query_fail {
             (false, None)
         } else {
@@ -580,6 +581,7 @@ impl ManagedRun {
             let rur = evict_req_outcome.into_run_update_resp();
             (should_report, rur)
         };
+
         let outcome = if self.pending_work_is_legacy_query() {
             if is_no_report_query_fail {
                 ActivationCompleteOutcome::WFTFailedDontReport
@@ -617,6 +619,7 @@ impl ManagedRun {
         } else {
             ActivationCompleteOutcome::WFTFailedDontReport
         };
+
         self.metrics
             .with_new_attrs([metrics::failure_reason(cause.into())])
             .wf_task_failed();
@@ -870,6 +873,19 @@ impl ManagedRun {
 
         if !self.activation_is_eviction() && self.trying_to_evict.is_none() {
             debug!(run_id=%info.run_id, reason=%info.message, "Eviction requested");
+            // If we've requested an eviction because of failure related reasons then we want to
+            // delete any pending queries, since handling them no longer makes sense. Evictions
+            // because the cache is full should get a chance to finish processing properly.
+            if !matches!(info.reason, EvictionReason::CacheFull)
+                // If the wft was just a legacy query, still reply, otherwise we might try to
+                // reply to the task as if it were a task rather than a query.
+                && !self.pending_work_is_legacy_query()
+            {
+                if let Some(wft) = self.wft.as_mut() {
+                    wft.pending_queries.clear();
+                }
+            }
+
             self.trying_to_evict = Some(info);
             EvictionRequestResult::EvictionRequested(attempts, self.check_more_activations())
         } else {
@@ -1456,8 +1472,8 @@ enum ActOrFulfill {
     FulfillableComplete(Option<FulfillableActivationComplete>),
 }
 
-#[derive(derive_more::DebugCustom)]
-#[debug(fmt = "RunUpdateErr({source:?})")]
+#[derive(derive_more::Debug)]
+#[debug("RunUpdateErr({source:?})")]
 struct RunUpdateErr {
     source: WFMachinesError,
     complete_resp_chan: Option<oneshot::Sender<ActivationCompleteResult>>,

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -44,12 +44,10 @@ use itertools::Itertools;
 use prost_types::TimestampError;
 use std::{
     cell::RefCell,
-    cmp::Ordering,
     collections::VecDeque,
     fmt::Debug,
     future::Future,
     mem,
-    mem::discriminant,
     ops::DerefMut,
     rc::Rc,
     result,
@@ -722,10 +720,7 @@ impl Workflows {
 /// Returned when a cache miss happens and we need to fetch history from the beginning to
 /// replay a run
 #[derive(Debug, derive_more::Display)]
-#[display(
-    fmt = "CacheMissFetchReq(run_id: {})",
-    "original_wft.work.execution.run_id"
-)]
+#[display("CacheMissFetchReq(run_id: {})", "original_wft.work.execution.run_id")]
 #[must_use]
 struct CacheMissFetchReq {
     original_wft: PermittedWFT,
@@ -751,11 +746,11 @@ enum ActivationOrAuto {
     /// This type should only be filled with an empty activation which is ready to have queries
     /// inserted into the joblist
     ReadyForQueries(WorkflowActivation),
-    #[display(fmt = "Autocomplete(run_id={run_id})")]
+    #[display("Autocomplete(run_id={run_id})")]
     Autocomplete {
         run_id: String,
     },
-    #[display(fmt = "AutoFail(run_id={run_id})")]
+    #[display("AutoFail(run_id={run_id})")]
     AutoFail {
         run_id: String,
         machines_err: WFMachinesError,
@@ -764,8 +759,8 @@ enum ActivationOrAuto {
 
 /// A WFT which is considered to be using a slot for metrics purposes and being or about to be
 /// applied to workflow state.
-#[derive(derive_more::DebugCustom)]
-#[debug(fmt = "PermittedWft({work:?})")]
+#[derive(derive_more::Debug)]
+#[debug("PermittedWft({work:?})")]
 pub(crate) struct PermittedWFT {
     work: PreparedWFT,
     permit: UsedMeteredSemPermit<WorkflowSlotKind>,
@@ -1247,19 +1242,13 @@ struct WorkflowStartedInfo {
 
 /// Wraps outgoing activation job protos with some internal details core might care about
 #[derive(Debug, derive_more::Display)]
-#[display(fmt = "{variant}")]
+#[display("{variant}")]
 struct OutgoingJob {
     variant: workflow_activation_job::Variant,
-    /// Since LA resolutions are not distinguished from non-LA resolutions as far as lang is
-    /// concerned, but core cares about that sometimes, attach that info here.
-    is_la_resolution: bool,
 }
 impl<WA: Into<workflow_activation_job::Variant>> From<WA> for OutgoingJob {
     fn from(wa: WA) -> Self {
-        Self {
-            variant: wa.into(),
-            is_la_resolution: false,
-        }
+        Self { variant: wa.into() }
     }
 }
 impl From<OutgoingJob> for WorkflowActivationJob {
@@ -1333,8 +1322,17 @@ impl LocalActivityRequestSink for LAReqSink {
 /// Sorts jobs in an activation to be in the order lang expects, and confirms any invariants
 /// activations must uphold.
 ///
-/// ## Ordering
-/// `patches -> signals/updates -> other -> queries -> evictions`
+/// ## Job Ordering
+/// 1. init workflow
+/// 2. patches
+/// 3. random-seed-updates
+/// 4. signals/updates
+/// 5. all others
+/// 6. local activity resolutions
+/// 7. queries
+/// 8. evictions
+///
+/// See the [WorkflowActivation] docstring for more detail
 ///
 /// ## Invariants:
 /// * Queries always go in their own activation
@@ -1361,26 +1359,26 @@ fn prepare_to_ship_activation(wfa: &mut WorkflowActivation) {
         // Unwrapping is fine here since we'll never issue empty variants
         let j1v = j1.variant.as_ref().unwrap();
         let j2v = j2.variant.as_ref().unwrap();
-        if discriminant(j1v) == discriminant(j2v) {
-            return Ordering::Equal;
-        }
         fn variant_ordinal(v: &workflow_activation_job::Variant) -> u8 {
             match v {
+                workflow_activation_job::Variant::InitializeWorkflow(_) => 0,
                 workflow_activation_job::Variant::NotifyHasPatch(_) => 1,
-                workflow_activation_job::Variant::SignalWorkflow(_) => 2,
-                workflow_activation_job::Variant::DoUpdate(_) => 2,
+                workflow_activation_job::Variant::UpdateRandomSeed(_) => 2,
+                workflow_activation_job::Variant::SignalWorkflow(_) => 3,
+                workflow_activation_job::Variant::DoUpdate(_) => 3,
+                workflow_activation_job::Variant::ResolveActivity(ra) if ra.is_local => 5,
                 // In principle we should never actually need to sort these with the others, since
                 // queries always get their own activation, but, maintaining the semantic is
                 // reasonable.
-                workflow_activation_job::Variant::QueryWorkflow(_) => 4,
+                workflow_activation_job::Variant::QueryWorkflow(_) => 6,
                 // Also shouldn't ever end up anywhere but the end by construction, but no harm in
                 // double-checking.
-                workflow_activation_job::Variant::RemoveFromCache(_) => 5,
-                _ => 3,
+                workflow_activation_job::Variant::RemoveFromCache(_) => 7,
+                _ => 4,
             }
         }
         variant_ordinal(j1v).cmp(&variant_ordinal(j2v))
-    })
+    });
 }
 
 #[cfg(test)]
@@ -1421,6 +1419,11 @@ mod tests {
                         Default::default(),
                     )),
                 },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::UpdateRandomSeed(
+                        Default::default(),
+                    )),
+                },
                 WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::SignalWorkflow(
                         SignalWorkflow {
@@ -1442,6 +1445,7 @@ mod tests {
             variants.as_slice(),
             &[
                 workflow_activation_job::Variant::NotifyHasPatch(_),
+                workflow_activation_job::Variant::UpdateRandomSeed(_),
                 workflow_activation_job::Variant::SignalWorkflow(ref s1),
                 workflow_activation_job::Variant::DoUpdate(_),
                 workflow_activation_job::Variant::SignalWorkflow(ref s2),

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -571,8 +571,8 @@ enum WFStreamInput {
 }
 
 /// A non-poller-received input to the [WFStream]
-#[derive(derive_more::DebugCustom)]
-#[debug(fmt = "LocalInput {{ {input:?} }}")]
+#[derive(derive_more::Debug)]
+#[debug("LocalInput {{ {input:?} }}")]
 pub(super) struct LocalInput {
     pub(super) input: LocalInputs,
     pub(super) span: Span,

package/sdk-core/core-api/src/telemetry.rs

@@ -54,6 +54,7 @@ pub struct OtelCollectorOptions {
     /// export to this same collector.
     pub url: Url,
     /// Optional set of HTTP headers to send to the Collector, e.g for authentication.
+    #[builder(default = "HashMap::new()")]
     pub headers: HashMap<String, String>,
     /// Optionally specify how frequently metrics should be exported. Defaults to 1 second.
     #[builder(default = "Duration::from_secs(1)")]

package/sdk-core/docker/docker-compose-telem.yaml

@@ -10,9 +10,9 @@ services:
 
   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
+      - ../etc/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
@@ -20,7 +20,7 @@ services:
       - '8889:8889' # Prometheus exporter metrics
       #      - "13133:13133" # health_check extension
       - '4317:4317' # OTLP gRPC receiver
-    #      - "55670:55679" # zpages extension
+    #      - "55679:55679" # zpages extension
     depends_on:
       - jaeger
 
@@ -28,6 +28,6 @@ services:
     container_name: prometheus
     image: prom/prometheus:latest
     volumes:
-      - ../../etc/prometheus.yaml:/etc/prometheus/prometheus.yml
+      - ../etc/prometheus.yaml:/etc/prometheus/prometheus.yml
     ports:
       - '9090:9090'

package/sdk-core/etc/otel-collector-config.yaml

@@ -2,16 +2,19 @@ receivers:
   otlp:
     protocols:
       grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
 
 exporters:
   prometheus:
     endpoint: '0.0.0.0:8889'
     namespace: temporal_sdk
+
   logging:
 
-  jaeger:
+  otlp/jaeger:
     endpoint: jaeger:14250
-    insecure: true
 
 processors:
   batch:
@@ -24,13 +27,13 @@ extensions:
     endpoint: :55679
 
 service:
-  extensions: [pprof, zpages, health_check]
+  extensions: [ pprof, zpages, health_check ]
   pipelines:
     traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [logging, jaeger]
+      receivers: [ otlp ]
+      processors: [ batch ]
+      exporters: [ logging, otlp/jaeger ]
     metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [logging, prometheus]
+      receivers: [ otlp ]
+      processors: [ batch ]
+      exporters: [ logging, prometheus ]