chore: Update sdk-core (#963)

Author: mjameswh

packages/core-bridge/Cargo.lock

@@ -1,5 +1,5 @@
 import { SpanContext } from '@opentelemetry/api';
-import { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
+import type { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
 
 export { TLSConfig };
 
@@ -53,32 +53,40 @@ export interface ClientOptions {
 
 /**
  * Log directly to console
+ *
+ * @experimental
  */
 export interface ConsoleLogger {
-  console: {};
+  console: {}; // eslint-disable-line @typescript-eslint/ban-types
 }
 
 /**
  * Forward logs to {@link Runtime} logger
+ *
+ * @experimental
  */
 export interface ForwardLogger {
   forward: {
     /**
      * What level, if any, logs should be forwarded from core at
      *
+     * @deprecated Use {@link TelemetryOptions.logging.filter} instead
      */
-    // These strings should match the log::LevelFilter enum in rust
-    level: LogLevel;
+    level?: LogLevel;
   };
 }
 
 /**
  * Logger types supported by Core
+ *
+ * @experimental
  */
 export type Logger = ConsoleLogger | ForwardLogger;
 
 /**
  * OpenTelemetry Collector options for exporting metrics or traces
+ *
+ * @experimental
  */
 export interface OtelCollectorExporter {
   otel: {
@@ -95,6 +103,8 @@ export interface OtelCollectorExporter {
 
 /**
  * Prometheus metrics exporter options
+ *
+ * @experimental
  */
 export interface PrometheusMetricsExporter {
   prometheus: {
@@ -114,24 +124,29 @@ export interface PrometheusMetricsExporter {
  * `temporality` is the type of aggregation temporality for metric export. Applies to both Prometheus and OpenTelemetry exporters.
  *
  * See the [OpenTelemetry specification](https://github.com/open-telemetry/opentelemetry-specification/blob/ce50e4634efcba8da445cc23523243cb893905cb/specification/metrics/datamodel.md#temporality) for more information.
+ *
+ * @experimental
  */
 export type MetricsExporter = {
   temporality?: 'cumulative' | 'delta';
 } & (PrometheusMetricsExporter | OtelCollectorExporter);
 
 /**
  * Trace exporters supported by Core
+ *
+ * @experimental
  */
 export type TraceExporter = OtelCollectorExporter;
 
+/** @experimental */
 export interface TelemetryOptions {
   /**
    * A string in the env filter format specified here:
    * https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html
    *
-   * Which determines what tracing data is collected in the Core SDK
+   * Which determines what tracing data is collected in the Core SDK.
    *
-   * @default `temporal_sdk_core=WARN`
+   * @deprecated Use either `logging.filter` or `tracing.filter` instead
    */
   tracingFilter?: string;
 
@@ -145,17 +160,50 @@ export interface TelemetryOptions {
 
   /**
    * Control where to send Rust Core logs
-   *
-   * @default log to console
    */
-  logging?: Logger;
+  logging?: {
+    /**
+     * A string in (env filter format)[https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html]
+     * which determines the verboseness of logging output.
+     *
+     * You can use {@link Runtime.makeTelemetryFilterString()} to easily build a correctly formatted filter
+     * string based on desired log level for Core SDK and other native packages.
+     *
+     * **BACKWARD COMPATIBILITY**
+     *
+     * If `logging.filter` is missing, the following legacy values (if present) will be used instead (in the given order):
+     * - {@link ForwardLogger.forward.level} => `makeTelemetryFilterString({ core: level, other: level })`
+     * - {@link TelemetryOptions.tracingFilter}
+     * - Default value of `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})`
+     *
+     * @default `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})` (with some exceptions, as described in backward compatibility note above)
+     */
+    filter?: string;
+  } & Partial<Logger>;
 
   /**
    * Control where to send traces generated by Rust Core, optional and turned off by default.
    *
    * This is typically used for profiling SDK internals.
    */
-  tracing?: TraceExporter;
+  tracing?: {
+    /**
+     * A string in (env filter format)[https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html]
+     * which determines what tracing data is collected in the Core SDK.
+     *
+     * You can use {@link Runtime.makeTelemetryFilterString()} to easily build a correctly formatted filter
+     * string based on desired log level for Core SDK and other native packages.
+     *
+     * **BACKWARD COMPATIBILITY**
+     *
+     * If `tracing.filter` is missing, the following legacy values (if present) will be used instead (in the given order):
+     * - {@link TelemetryOptions.tracingFilter}
+     * - Default value of `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})`
+     *
+     * @default `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})` (with some exceptions, as described in backward compatibility note above)
+     */
+    filter?: string;
+  } & Partial<TraceExporter>;
 
   /**
    * Control exporting {@link NativeConnection} and {@link Worker} metrics.
@@ -165,6 +213,21 @@ export interface TelemetryOptions {
   metrics?: MetricsExporter;
 }
 
+/** @experimental */
+export type CompiledTelemetryOptions = {
+  noTemporalPrefixForMetrics?: boolean;
+  logging: {
+    filter: string;
+  } & (
+    | { console: {} /* eslint-disable-line @typescript-eslint/ban-types */ }
+    | { forward: {} /* eslint-disable-line @typescript-eslint/ban-types */ }
+  );
+  tracing?: {
+    filter: string;
+  } & TraceExporter;
+  metrics?: MetricsExporter;
+};
+
 export interface WorkerOptions {
   /**
    * A human-readable string that can identify your worker
@@ -367,8 +430,7 @@ export declare type LogsCallback = (err: Error, result: LogEntry[]) => void;
 
 // TODO: improve type, for some reason Error is not accepted here
 export declare function registerErrors(errors: Record<string, any>): void;
-export declare function initTelemetry(telemOptions: TelemetryOptions): void;
-export declare function newRuntime(): Runtime;
+export declare function newRuntime(telemOptions: CompiledTelemetryOptions): Runtime;
 export declare function newClient(runtime: Runtime, clientOptions: ClientOptions, callback: ClientCallback): void;
 export declare function newWorker(client: Client, workerOptions: WorkerOptions, callback: WorkerCallback): void;
 export declare function newReplayWorker(

packages/core-bridge/index.d.ts

@@ -1,5 +1,4 @@
 use crate::helpers::*;
-use log::LevelFilter;
 use neon::{
     context::Context,
     handle::Handle,
@@ -9,13 +8,15 @@ use neon::{
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
 use std::{collections::HashMap, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
+    api::telemetry::{
+        Logger, MetricTemporality, MetricsExporter, OtelCollectorOptions, TelemetryOptions,
+        TelemetryOptionsBuilder, TraceExportConfig, TraceExporter,
+    },
     api::worker::{WorkerConfig, WorkerConfigBuilder},
     ephemeral_server::{
         TemporaliteConfig, TemporaliteConfigBuilder, TestServerConfig, TestServerConfigBuilder,
     },
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricTemporality,
-    MetricsExporter, OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder,
-    TlsConfig, TraceExporter, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TlsConfig, Url,
 };
 
 pub enum EphemeralServerConfig {
@@ -151,7 +152,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                 ) as u64),
                 max_elapsed_time: js_optional_value_getter!(
                     cx,
-                    &retry_config,
+                    retry_config,
                     "maxElapsedTime",
                     JsNumber
                 )
@@ -176,38 +177,27 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-
-        if let Some(tf) = js_optional_value_getter!(cx, self, "tracingFilter", JsString) {
-            telemetry_opts.tracing_filter(tf);
-        }
         telemetry_opts.no_temporal_prefix_for_metrics(
             js_optional_value_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
                 .unwrap_or_default(),
         );
+
         if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
-            if let Some(_) = get_optional(cx, logging, "console") {
-                telemetry_opts.logging(Logger::Console);
-            } else if let Some(ref forward) = js_optional_getter!(cx, logging, "forward", JsObject)
-            {
-                let level = js_value_getter!(cx, forward, "level", JsString);
-                match LevelFilter::from_str(&level) {
-                    Ok(level) => {
-                        telemetry_opts.logging(Logger::Forward(level));
-                    }
-                    Err(err) => cx.throw_type_error(format!(
-                        "Invalid telemetryOptions.logging.forward.level: {}",
-                        err
-                    ))?,
-                }
+            let filter = js_value_getter!(cx, logging, "filter", JsString);
+            if get_optional(cx, logging, "console").is_some() {
+                telemetry_opts.logging(Logger::Console { filter });
+            } else if get_optional(cx, logging, "forward").is_some() {
+                telemetry_opts.logging(Logger::Forward { filter });
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.logging, missing `console` or `forward` option"
-                ))?
+                cx.throw_type_error(
+                    "Invalid telemetryOptions.logging, expected either 'console' or 'forward' property",
+                )?;
             }
         }
-        if let Some(metrics) = js_optional_getter!(cx, self, "metrics", JsObject) {
+
+        if let Some(ref metrics) = js_optional_getter!(cx, self, "metrics", JsObject) {
             if let Some(temporality) =
-                js_optional_value_getter!(cx, &metrics, "temporality", JsString)
+                js_optional_value_getter!(cx, metrics, "temporality", JsString)
             {
                 match temporality.as_str() {
                     "cumulative" => {
@@ -221,56 +211,60 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     }
                 };
             }
-
-            if let Some(ref prom) = js_optional_getter!(cx, &metrics, "prometheus", JsObject) {
+            if let Some(ref prom) = js_optional_getter!(cx, metrics, "prometheus", JsObject) {
                 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(
                         "Invalid telemetryOptions.metrics.prometheus.bindAddress",
                     )?,
                 };
-            } else if let Some(ref otel) = js_optional_getter!(cx, &metrics, "otel", JsObject) {
+            } else if let Some(ref otel) = js_optional_getter!(cx, metrics, "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.metrics.otel.url")?,
                 };
                 let headers =
-                    if let Some(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                    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
                     .metrics(MetricsExporter::Otel(OtelCollectorOptions { url, headers }));
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option"
-                ))?
+                cx.throw_type_error(
+                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option",
+                )?
             }
         }
 
-        if let Some(tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
-            if let Some(ref otel) = js_optional_getter!(cx, &tracing, "otel", 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(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                    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(TraceExporter::Otel(OtelCollectorOptions { url, headers }));
+                telemetry_opts.tracing(TraceExportConfig {
+                    filter,
+                    exporter: TraceExporter::Otel(OtelCollectorOptions { url, headers }),
+                });
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.tracing, missing `otel` option"
-                ))?
+                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()
@@ -363,7 +357,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let executable = match exec_type.as_str() {
             "cached-download" => {
                 let version = js_optional_value_getter!(cx, &js_executable, "version", JsString)
-                    .unwrap_or("default".to_owned());
+                    .unwrap_or_else(|| "default".to_owned());
                 let dest_dir =
                     js_optional_value_getter!(cx, &js_executable, "downloadDir", JsString);
 

packages/core-bridge/sdk-core

@@ -14,7 +14,6 @@ use testing::*;
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("getTimeOfDay", get_time_of_day)?;
     cx.export_function("registerErrors", errors::register_errors)?;
-    cx.export_function("initTelemetry", init_telemetry)?;
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("newClient", client_new)?;
     cx.export_function("clientUpdateHeaders", client_update_headers)?;