Self review

Author: mjameswh

packages/activity/src/index.ts

@@ -284,8 +284,8 @@ export class Context {
   /**
    * Get the metric meter for this activity with activity-specific tags.
    *
-   * To add custom tags, register a {@link ActivityOutboundCallsInterceptor} that intercepts the
-   * `getMetricsTags()` method.
+   * To add custom tags, register a {@link ActivityOutboundCallsInterceptor} that
+   * intercepts the `getMetricTags()` method.
    */
   public readonly metricMeter: MetricMeter;
 
@@ -447,6 +447,11 @@ export function cancellationSignal(): AbortSignal {
 
 /**
  * Get the metric meter for the current activity, with activity-specific tags.
+ *
+ * To add custom tags, register a {@link ActivityOutboundCallsInterceptor} that
+ * intercepts the `getMetricTags()` method.
+ *
+ * This is a shortcut for `Context.current().metricMeter` (see {@link Context.metricMeter}).
  */
 export const metricMeter: MetricMeter = {
   createCounter(name, unit, description) {

packages/common/src/metrics.ts

@@ -231,7 +231,7 @@ export type MetricTagsOrFunc = MetricTags | (() => MetricTags);
  * @internal
  * @hidden
  */
-export class MetricsMeterWithComposedTags implements MetricMeter {
+export class MetricMeterWithComposedTags implements MetricMeter {
   /**
    * Return a {@link MetricMeter} that adds tags before delegating calls to a parent meter.
    *
@@ -244,20 +244,20 @@ export class MetricsMeterWithComposedTags implements MetricMeter {
    * @param meter The parent meter to delegate calls to.
    * @param tagsOrFunc New tags may either be specified statically as a delta object, or as a function
    *                   evaluated every time a metric is recorded that will return a delta object.
-   * @param force if `true`, then a `MetricsMeterWithComposedTags` will be created even if there
+   * @param force if `true`, then a `MetricMeterWithComposedTags` will be created even if there
    *              is no tags to add. This is useful to add tags support to an underlying meter
    *              implementation that does not support tags directly.
    */
   public static compose(meter: MetricMeter, tagsOrFunc: MetricTagsOrFunc, force: boolean = false): MetricMeter {
-    if (meter instanceof MetricsMeterWithComposedTags) {
+    if (meter instanceof MetricMeterWithComposedTags) {
       const contributors = appendToChain(meter.contributors, tagsOrFunc);
       // If the new contributor results in no actual change to the chain, then we don't need a new meter
       if (contributors === undefined && !force) return meter;
-      return new MetricsMeterWithComposedTags(meter.parentMeter, contributors ?? []);
+      return new MetricMeterWithComposedTags(meter.parentMeter, contributors ?? []);
     } else {
       const contributors = appendToChain(undefined, tagsOrFunc);
       if (contributors === undefined && !force) return meter;
-      return new MetricsMeterWithComposedTags(meter, contributors ?? []);
+      return new MetricMeterWithComposedTags(meter, contributors ?? []);
     }
   }
 
@@ -292,7 +292,7 @@ export class MetricsMeterWithComposedTags implements MetricMeter {
   }
 
   withTags(tags: MetricTags): MetricMeter {
-    return MetricsMeterWithComposedTags.compose(this, tags);
+    return MetricMeterWithComposedTags.compose(this, tags);
   }
 }
 

packages/core-bridge/src/metrics.rs

@@ -16,7 +16,6 @@ use temporal_sdk_core::api::telemetry::metrics::{
 };
 
 use bridge_macros::js_function;
-use temporal_sdk_core::CoreRuntime;
 
 use crate::helpers::{
     BridgeError, BridgeResult, JsonString, MutableFinalize, OpaqueInboundHandle,
@@ -44,41 +43,31 @@ pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<
 }
 
 pub struct Counter {
-    // We only hang on to Runtime to ensure proper shutdown sequencing
-    // core_runtime: Arc<CoreRuntime>,
     pub(crate) meter: TemporalMeter,
     pub(crate) counter: Arc<dyn CoreCounter>,
 }
 
 impl MutableFinalize for Counter {}
 
 pub struct Histogram {
-    // We only hang on to Runtime to ensure proper shutdown sequencing
-    // core_runtime: Arc<CoreRuntime>,
     pub(crate) meter: TemporalMeter,
     pub(crate) histogram: Arc<dyn CoreHistogram>,
 }
 impl MutableFinalize for Histogram {}
 
 pub struct HistogramF64 {
-    // We only hang on to Runtime to ensure proper shutdown sequencing
-    // core_runtime: Arc<CoreRuntime>,
     pub(crate) meter: TemporalMeter,
     pub(crate) histogram: Arc<dyn CoreHistogramF64>,
 }
 impl MutableFinalize for HistogramF64 {}
 
 pub struct Gauge {
-    // We only hang on to Runtime to ensure proper shutdown sequencing
-    // core_runtime: Arc<CoreRuntime>,
     pub(crate) meter: TemporalMeter,
     pub(crate) gauge: Arc<dyn CoreGauge>,
 }
 impl MutableFinalize for Gauge {}
 
 pub struct GaugeF64 {
-    // We only hang on to Runtime to ensure proper shutdown sequencing
-    // core_runtime: Arc<CoreRuntime>,
     pub(crate) meter: TemporalMeter,
     pub(crate) gauge: Arc<dyn CoreGaugeF64>,
 }
@@ -135,11 +124,7 @@ pub fn new_metric_counter(
             .context("Failed to build metric parameters")?,
     );
 
-    Ok(OpaqueOutboundHandle::new(Counter {
-        // core_runtime,
-        meter,
-        counter,
-    }))
+    Ok(OpaqueOutboundHandle::new(Counter { meter, counter }))
 }
 
 #[js_function]
@@ -166,11 +151,7 @@ pub fn new_metric_histogram(
             .context("Failed to build metric parameters")?,
     );
 
-    Ok(OpaqueOutboundHandle::new(Histogram {
-        //  core_runtime,
-        meter,
-        histogram,
-    }))
+    Ok(OpaqueOutboundHandle::new(Histogram { meter, histogram }))
 }
 
 #[js_function]
@@ -197,11 +178,7 @@ pub fn new_metric_histogram_f64(
             .context("Failed to build metric parameters")?,
     );
 
-    Ok(OpaqueOutboundHandle::new(HistogramF64 {
-        // core_runtime,
-        meter,
-        histogram,
-    }))
+    Ok(OpaqueOutboundHandle::new(HistogramF64 { meter, histogram }))
 }
 
 #[js_function]
@@ -228,11 +205,7 @@ pub fn new_metric_gauge(
             .context("Failed to build metric parameters")?,
     );
 
-    Ok(OpaqueOutboundHandle::new(Gauge {
-        //  core_runtime,
-        meter,
-        gauge,
-    }))
+    Ok(OpaqueOutboundHandle::new(Gauge { meter, gauge }))
 }
 
 #[js_function]
@@ -259,11 +232,7 @@ pub fn new_metric_gauge_f64(
             .context("Failed to build metric parameters")?,
     );
 
-    Ok(OpaqueOutboundHandle::new(GaugeF64 {
-        // core_runtime,
-        meter,
-        gauge,
-    }))
+    Ok(OpaqueOutboundHandle::new(GaugeF64 { meter, gauge }))
 }
 
 #[js_function]

packages/core-bridge/ts/native.ts

@@ -377,27 +377,27 @@ type LogEntryMetadata = {
 // Custom Metrics
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export interface NativeMetricMeter {
+export interface MetricMeter {
   type: 'metric-meter';
 }
 
-export interface NativeMetricCounter {
+export interface MetricCounter {
   type: 'metric-counter';
 }
 
-export interface NativeMetricHistogram {
+export interface MetricHistogram {
   type: 'metric-histogram';
 }
 
-export interface NativeMetricHistogramF64 {
+export interface MetricHistogramF64 {
   type: 'metric-histogram-f64';
 }
 
-export interface NativeMetricGauge {
+export interface MetricGauge {
   type: 'metric-gauge';
 }
 
-export interface NativeMetricGaugeF64 {
+export interface MetricGaugeF64 {
   type: 'metric-gauge-f64';
 }
 
@@ -408,62 +408,57 @@ export declare function newMetricCounter(
   name: string,
   unit: string,
   description: string
-): NativeMetricCounter;
+): MetricCounter;
 
 export declare function newMetricHistogram(
   runtime: Runtime,
   name: string,
   unit: string,
   description: string
-): NativeMetricHistogram;
+): MetricHistogram;
 
 export declare function newMetricHistogramF64(
   runtime: Runtime,
   name: string,
   unit: string,
   description: string
-): NativeMetricHistogramF64;
+): MetricHistogramF64;
 
-export declare function newMetricGauge(
-  runtime: Runtime,
-  name: string,
-  unit: string,
-  description: string
-): NativeMetricGauge;
+export declare function newMetricGauge(runtime: Runtime, name: string, unit: string, description: string): MetricGauge;
 
 export declare function newMetricGaugeF64(
   runtime: Runtime,
   name: string,
   unit: string,
   description: string
-): NativeMetricGaugeF64;
+): MetricGaugeF64;
 
 export declare function addMetricCounterValue(
-  counter: NativeMetricCounter,
+  counter: MetricCounter,
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;
 
 export declare function recordMetricHistogramValue(
-  histogram: NativeMetricHistogram,
+  histogram: MetricHistogram,
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;
 
 export declare function recordMetricHistogramF64Value(
-  histogram: NativeMetricHistogramF64,
+  histogram: MetricHistogramF64,
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;
 
 export declare function setMetricGaugeValue(
-  gauge: NativeMetricGauge,
+  gauge: MetricGauge,
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;
 
 export declare function setMetricGaugeF64Value(
-  gauge: NativeMetricGaugeF64,
+  gauge: MetricGaugeF64,
   value: number,
   attrs: JsonString<MetricAttributes>
 ): void;

packages/proto/scripts/compile-proto.js

@@ -9,24 +9,8 @@ const pbts = require('protobufjs-cli/pbts');
 const outputDir = resolve(__dirname, '../protos');
 const jsOutputFile = resolve(outputDir, 'json-module.js');
 const tempFile = resolve(outputDir, 'temp.js');
-const protoBaseDir = resolve(__dirname, '../../core-bridge/sdk-core/sdk-core-protos/protos');
 
-const coreProtoPath = resolve(protoBaseDir, 'local/temporal/sdk/core/core_interface.proto');
-const workflowServiceProtoPath = resolve(protoBaseDir, 'api_upstream/temporal/api/workflowservice/v1/service.proto');
-const operatorServiceProtoPath = resolve(protoBaseDir, 'api_upstream/temporal/api/operatorservice/v1/service.proto');
-const cloudServiceProtoPath = resolve(
-  protoBaseDir,
-  'api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto'
-);
-const errorDetailsProtoPath = resolve(protoBaseDir, 'api_upstream/temporal/api/errordetails/v1/message.proto');
-const workflowMetadataProtoPath = resolve(protoBaseDir, 'api_upstream/temporal/api/sdk/v1/workflow_metadata.proto');
-const testServiceRRProtoPath = resolve(
-  protoBaseDir,
-  'testsrv_upstream/temporal/api/testservice/v1/request_response.proto'
-);
-const testServiceProtoPath = resolve(protoBaseDir, 'testsrv_upstream/temporal/api/testservice/v1/service.proto');
-const healthServiceProtoPath = resolve(protoBaseDir, 'grpc/health/v1/health.proto');
-const googleRpcStatusProtoPath = resolve(protoBaseDir, 'google/rpc/status.proto');
+const protoBaseDir = resolve(__dirname, '../../core-bridge/sdk-core/sdk-core-protos/protos');
 
 function mtime(path) {
   try {
@@ -40,28 +24,15 @@ function mtime(path) {
 }
 
 async function compileProtos(dtsOutputFile, ...args) {
-  // Use --root to avoid conflicting with user's root
-  // and to avoid this error: https://github.com/protobufjs/protobuf.js/issues/1114
   const pbjsArgs = [
-    ...args,
-    '--wrap',
-    'commonjs',
+    ...['--wrap', 'commonjs'],
     '--force-long',
     '--no-verify',
     '--alt-comment',
-    '--root',
-    '__temporal',
-    resolve(require.resolve('protobufjs'), '../google/protobuf/descriptor.proto'),
-    coreProtoPath,
-    workflowServiceProtoPath,
-    operatorServiceProtoPath,
-    cloudServiceProtoPath,
-    errorDetailsProtoPath,
-    workflowMetadataProtoPath,
-    testServiceRRProtoPath,
-    testServiceProtoPath,
-    healthServiceProtoPath,
-    googleRpcStatusProtoPath,
+    // Use --root to avoid conflicting with user's root
+    // and to avoid this error: https://github.com/protobufjs/protobuf.js/issues/1114
+    ...['--root', '__temporal'],
+    ...args,
   ];
 
   console.log(`Creating protobuf JS definitions`);
@@ -101,14 +72,32 @@ async function main() {
     return;
   }
 
-  await compileProtos(
-    resolve(outputDir, 'root.d.ts'),
-    '--path',
+  const rootDirs = [
     resolve(protoBaseDir, 'api_upstream'),
-    '--path',
+    resolve(protoBaseDir, 'testsrv_upstream'),
     resolve(protoBaseDir, 'local'),
-    '--path',
-    resolve(protoBaseDir, 'api_cloud_upstream')
+    resolve(protoBaseDir, 'api_cloud_upstream'),
+    protoBaseDir, // 'grpc' and 'google' are directly under protoBaseDir
+  ];
+
+  const entrypoints = [
+    'temporal/sdk/core/core_interface.proto',
+    'temporal/api/workflowservice/v1/service.proto',
+    'temporal/api/operatorservice/v1/service.proto',
+    'temporal/api/cloud/cloudservice/v1/service.proto',
+    'temporal/api/errordetails/v1/message.proto',
+    'temporal/api/sdk/v1/workflow_metadata.proto',
+    'temporal/api/testservice/v1/request_response.proto',
+    'temporal/api/testservice/v1/service.proto',
+    'grpc/health/v1/health.proto',
+    'google/rpc/status.proto',
+  ];
+
+  await compileProtos(
+    resolve(outputDir, 'root.d.ts'),
+    // Make sure to include all
+    ...rootDirs.flatMap((dir) => ['--path', dir]),
+    ...entrypoints
   );
 
   console.log('Done');