chore!: Remove SDK tracing support (#1269)

Author: mjameswh

package-lock.json

@@ -53,7 +53,6 @@
     "@opentelemetry/api": "^1.4.1",
     "@opentelemetry/core": "^1.12.0",
     "@opentelemetry/sdk-node": "^0.38.0",
-    "@opentelemetry/semantic-conventions": "^1.12.0",
     "@tsconfig/node14": "^1.0.3",
     "@types/dedent": "^0.7.0",
     "@types/fs-extra": "^9.0.13",

package.json

@@ -12,7 +12,6 @@
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.4.1",
     "@temporalio/proto": "file:../proto",
     "long": "^5.2.0",
     "ms": "^3.0.0-canary.1",

packages/common/package.json

@@ -22,7 +22,6 @@
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.4.1",
     "@temporalio/common": "file:../common",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",

packages/common/src/otel.ts

@@ -5,12 +5,11 @@ use neon::{
     prelude::*,
     types::{JsBoolean, JsNumber, JsString},
 };
-use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
-use std::{collections::HashMap, net::SocketAddr, str::FromStr, time::Duration};
+use std::{collections::HashMap, net::SocketAddr, time::Duration};
 use temporal_sdk_core::{
     api::telemetry::{
         Logger, MetricTemporality, MetricsExporter, OtelCollectorOptions, TelemetryOptions,
-        TelemetryOptionsBuilder, TraceExportConfig, TraceExporter,
+        TelemetryOptionsBuilder,
     },
     api::worker::{WorkerConfig, WorkerConfigBuilder},
     ephemeral_server::{
@@ -44,7 +43,6 @@ impl ArrayHandleConversionsExt for Handle<'_, JsArray> {
 
 pub trait ObjectHandleConversionsExt {
     fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()>;
-    fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext>;
     fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions>;
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig>;
@@ -60,19 +58,6 @@ pub trait ObjectHandleConversionsExt {
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
-    fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext> {
-        let trace_id = js_value_getter!(ctx, self, "traceId", JsString);
-        let span_id = js_value_getter!(ctx, self, "spanId", JsString);
-        let trace_flags = js_value_getter!(ctx, self, "traceFlags", JsNumber);
-        Ok(SpanContext::new(
-            TraceId::from_hex(&trace_id).expect("TraceId is valid"),
-            SpanId::from_hex(&span_id).expect("SpanId is valid"),
-            TraceFlags::new(trace_flags as u8),
-            false,
-            TraceState::from_str("").expect("Trace state must be valid"),
-        ))
-    }
-
     fn as_hash_map_of_string_to_string(
         &self,
         cx: &mut FunctionContext,
@@ -213,7 +198,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                 };
             }
             if let Some(ref prom) = js_optional_getter!(cx, metrics, "prometheus", JsObject) {
-                let addr = js_value_getter!(cx, prom, "bindAddress", JsString);
+                                let addr = js_value_getter!(cx, prom, "bindAddress", JsString);
                 match addr.parse::<SocketAddr>() {
                     Ok(address) => telemetry_opts.metrics(MetricsExporter::Prometheus(address)),
                     Err(_) => cx.throw_type_error(
@@ -250,33 +235,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             }
         }
 
-        if let Some(ref tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
-            let filter = js_value_getter!(cx, tracing, "filter", JsString);
-            if let Some(ref otel) = js_optional_getter!(cx, tracing, "otel", JsObject) {
-                let url = js_value_getter!(cx, otel, "url", JsString);
-                let url = match Url::parse(&url) {
-                    Ok(url) => url,
-                    Err(_) => cx.throw_type_error("Invalid telemetryOptions.tracing.otel.url")?,
-                };
-                let headers =
-                    if let Some(ref headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
-                        headers.as_hash_map_of_string_to_string(cx)?
-                    } else {
-                        Default::default()
-                    };
-                telemetry_opts.tracing(TraceExportConfig {
-                    filter,
-                    exporter: TraceExporter::Otel(OtelCollectorOptions {
-                        url,
-                        headers,
-                        metric_periodicity: None,
-                    }),
-                });
-            } else {
-                cx.throw_type_error("Invalid telemetryOptions.tracing, missing `otel` option")?
-            }
-        }
-
         telemetry_opts.build().map_err(|reason| {
             cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
                 .unwrap_err()

packages/core-bridge/package.json

@@ -1,7 +1,6 @@
 use crate::{conversions::ObjectHandleConversionsExt, errors::*, helpers::*, runtime::*};
 use futures::stream::StreamExt;
 use neon::{prelude::*, types::buffer::TypedArray};
-use opentelemetry::trace::{FutureExt, SpanContext, TraceContextExt};
 use prost::Message;
 use std::{cell::RefCell, sync::Arc};
 use temporal_sdk_core::replay::HistoryForReplay;
@@ -42,27 +41,23 @@ pub enum WorkerRequest {
     },
     /// A request to poll for workflow activations
     PollWorkflowActivation {
-        otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
     /// A request to complete a single workflow activation
     CompleteWorkflowActivation {
         completion: WorkflowActivationCompletion,
-        otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
     /// A request to poll for activity tasks
     PollActivityTask {
-        otel_span: SpanContext,
         /// Used to report completion or error back into JS
         callback: Root<JsFunction>,
     },
     /// A request to complete a single activity task
     CompleteActivityTask {
         completion: ActivityTaskCompletion,
-        otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
@@ -89,35 +84,29 @@ pub async fn start_worker_loop(
                         send_result(channel, callback, |cx| Ok(cx.undefined()));
                     }
                     WorkerRequest::PollWorkflowActivation {
-                        otel_span,
                         callback,
                     } => {
                         handle_poll_workflow_activation_request(
-                            worker, otel_span, channel, callback,
+                            worker, channel, callback,
                         )
                         .await
                     }
                     WorkerRequest::PollActivityTask {
-                        otel_span,
                         callback,
                     } => {
-                        handle_poll_activity_task_request(worker, otel_span, channel, callback)
+                        handle_poll_activity_task_request(worker, channel, callback)
                             .await
                     }
                     WorkerRequest::CompleteWorkflowActivation {
                         completion,
-                        otel_span,
                         callback,
                     } => {
-                        let otel_ctx =
-                            opentelemetry::Context::new().with_remote_span_context(otel_span);
                         void_future_to_js(
                             channel,
                             callback,
                             async move {
                                 worker
                                     .complete_workflow_activation(completion)
-                                    .with_context(otel_ctx)
                                     .await
                             },
                             |cx, err| -> JsResult<JsObject> {
@@ -132,18 +121,14 @@ pub async fn start_worker_loop(
                     }
                     WorkerRequest::CompleteActivityTask {
                         completion,
-                        otel_span,
                         callback,
                     } => {
-                        let otel_ctx =
-                            opentelemetry::Context::new().with_remote_span_context(otel_span);
                         void_future_to_js(
                             channel,
                             callback,
                             async move {
                                 worker
                                     .complete_activity_task(completion)
-                                    .with_context(otel_ctx)
                                     .await
                             },
                             |cx, err| -> JsResult<JsObject> {
@@ -170,14 +155,11 @@ pub async fn start_worker_loop(
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 async fn handle_poll_workflow_activation_request(
     worker: &CoreWorker,
-    span_context: SpanContext,
     channel: Arc<Channel>,
     callback: Root<JsFunction>,
 ) {
-    let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
     match worker
         .poll_workflow_activation()
-        .with_context(otel_ctx)
         .await
     {
         Ok(task) => {
@@ -207,12 +189,10 @@ async fn handle_poll_workflow_activation_request(
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 pub async fn handle_poll_activity_task_request(
     worker: &CoreWorker,
-    span_context: SpanContext,
     channel: Arc<Channel>,
     callback: Root<JsFunction>,
 ) {
-    let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
-    match worker.poll_activity_task().with_context(otel_ctx).await {
+    match worker.poll_activity_task().await {
         Ok(task) => {
             send_result(channel, callback, move |cx| {
                 let len = task.encoded_len();
@@ -321,15 +301,13 @@ pub fn close_history_stream(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 /// There should be only one concurrent poll request for this type.
 pub fn worker_poll_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
-    let otel_span = cx.argument::<JsObject>(1)?;
-    let callback = cx.argument::<JsFunction>(2)?;
+    let callback = cx.argument::<JsFunction>(1)?;
     match worker.borrow().as_ref() {
         None => {
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
         }
         Some(worker) => {
             let request = WorkerRequest::PollWorkflowActivation {
-                otel_span: otel_span.as_otel_span_context(&mut cx)?,
                 callback: callback.root(&mut cx),
             };
             if let Err(err) = worker.sender.send(request) {
@@ -344,15 +322,13 @@ pub fn worker_poll_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUn
 /// There should be only one concurrent poll request for this type.
 pub fn worker_poll_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
-    let otel_span = cx.argument::<JsObject>(1)?;
-    let callback = cx.argument::<JsFunction>(2)?;
+    let callback = cx.argument::<JsFunction>(1)?;
     match worker.borrow().as_ref() {
         None => {
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
         }
         Some(worker) => {
             let request = WorkerRequest::PollActivityTask {
-                otel_span: otel_span.as_otel_span_context(&mut cx)?,
                 callback: callback.root(&mut cx),
             };
             if let Err(err) = worker.sender.send(request) {
@@ -366,9 +342,8 @@ pub fn worker_poll_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefine
 /// Submit a workflow activation completion to core.
 pub fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
-    let otel_span = cx.argument::<JsObject>(1)?;
-    let completion = cx.argument::<JsArrayBuffer>(2)?;
-    let callback = cx.argument::<JsFunction>(3)?;
+    let completion = cx.argument::<JsArrayBuffer>(1)?;
+    let callback = cx.argument::<JsFunction>(2)?;
     match worker.borrow().as_ref() {
         None => {
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
@@ -378,7 +353,6 @@ pub fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<
                 Ok(completion) => {
                     let request = WorkerRequest::CompleteWorkflowActivation {
                         completion,
-                        otel_span: otel_span.as_otel_span_context(&mut cx)?,
                         callback: callback.root(&mut cx),
                     };
                     if let Err(err) = worker.sender.send(request) {
@@ -397,9 +371,8 @@ pub fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<
 /// Submit an activity task completion to core.
 pub fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
-    let otel_span = cx.argument::<JsObject>(1)?;
-    let result = cx.argument::<JsArrayBuffer>(2)?;
-    let callback = cx.argument::<JsFunction>(3)?;
+    let result = cx.argument::<JsArrayBuffer>(1)?;
+    let callback = cx.argument::<JsFunction>(2)?;
     match worker.borrow().as_ref() {
         None => {
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
@@ -409,7 +382,6 @@ pub fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUnde
                 Ok(completion) => {
                     let request = WorkerRequest::CompleteActivityTask {
                         completion,
-                        otel_span: otel_span.as_otel_span_context(&mut cx)?,
                         callback: callback.root(&mut cx),
                     };
                     if let Err(err) = worker.sender.send(request) {