@nocobase/telemetry 2.0.0-alpha.5 → 2.0.0-alpha.51

package/lib/index.d.ts

@@ -7,3 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export * from './telemetry';
+export * from './metric';
+export * from './trace';
+export { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+export { Meter } from '@opentelemetry/api';

package/lib/index.js

@@ -11,6 +11,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,9 +26,21 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
+__export(src_exports, {
+  Meter: () => import_api.Meter,
+  PeriodicExportingMetricReader: () => import_sdk_metrics.PeriodicExportingMetricReader
+});
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("./telemetry"), module.exports);
+__reExport(src_exports, require("./metric"), module.exports);
+__reExport(src_exports, require("./trace"), module.exports);
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_api = require("@opentelemetry/api");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./telemetry")
+  Meter,
+  PeriodicExportingMetricReader,
+  ...require("./telemetry"),
+  ...require("./metric"),
+  ...require("./trace")
 });

package/lib/metric.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Registry } from '@nocobase/utils';
-import { MetricReader, MeterProvider, View } from '@opentelemetry/sdk-metrics';
+import { MetricReader, MeterProvider } from '@opentelemetry/sdk-metrics';
 import { Resource } from '@opentelemetry/resources';
 export type MetricOptions = {
     meterName?: string;
@@ -20,15 +20,15 @@ export declare class Metric {
     version: string;
     readerName: string | string[];
     readers: Registry<GetMetricReader>;
-    provider: MeterProvider;
-    views: View[];
+    provider?: MeterProvider;
+    resource?: Resource;
+    activeReaders: MetricReader[];
     constructor(options?: MetricOptions);
     init(resource: Resource): void;
     registerReader(name: string, reader: GetMetricReader): void;
     getReader(name: string): GetMetricReader;
-    addView(...view: View[]): void;
-    getMeter(name?: string, version?: string): import("@opentelemetry/api").Meter;
     start(): void;
+    getMeter(name?: string, version?: string): import("@opentelemetry/api").Meter;
     shutdown(): Promise<void>;
 }
 export {};

package/lib/metric.js

@@ -49,7 +49,8 @@ const _Metric = class _Metric {
   readerName;
   readers = new import_utils.Registry();
   provider;
-  views = [];
+  resource;
+  activeReaders = [];
   constructor(options) {
     const { meterName, readerName, version } = options || {};
     this.readerName = readerName || "console";
@@ -58,13 +59,14 @@ const _Metric = class _Metric {
     this.registerReader(
       "console",
       () => new import_sdk_metrics.PeriodicExportingMetricReader({
-        exporter: new import_sdk_metrics.ConsoleMetricExporter()
+        exporter: new import_sdk_metrics.ConsoleMetricExporter({
+          temporalitySelector: /* @__PURE__ */ __name(() => import_sdk_metrics.AggregationTemporality.DELTA, "temporalitySelector")
+        })
       })
     );
   }
   init(resource) {
-    this.provider = new import_sdk_metrics.MeterProvider({ resource, views: this.views });
-    import_api.default.metrics.setGlobalMeterProvider(this.provider);
+    this.resource = resource;
   }
   registerReader(name, reader) {
     this.readers.register(name, reader);
@@ -72,24 +74,58 @@ const _Metric = class _Metric {
   getReader(name) {
     return this.readers.get(name);
   }
-  addView(...view) {
-    this.views.push(...view);
+  start() {
+    if (!this.resource) {
+      throw new Error("Metric.init(resource) must be called before start()");
+    }
+    const metricNames = new Set(
+      (process.env.TELEMETRY_METRICS || "").split(",").map((s) => s.trim()).filter(Boolean)
+    );
+    const views = [];
+    if (metricNames.size > 0) {
+      for (const metricName of metricNames) {
+        views.push({
+          instrumentName: metricName
+        });
+      }
+      views.push({
+        instrumentName: "*",
+        aggregation: { type: import_sdk_metrics.AggregationType.DROP }
+      });
+    }
+    let readerNames = this.readerName;
+    if (typeof readerNames === "string") {
+      readerNames = readerNames.split(",").map((n) => n.trim()).filter(Boolean);
+    }
+    const readers = [];
+    for (const name of readerNames) {
+      const reader = this.readers.get(name);
+      if (!reader) {
+        continue;
+      }
+      readers.push(reader());
+    }
+    this.activeReaders = readers;
+    const providerOptions = {
+      resource: this.resource,
+      readers
+    };
+    if (views.length > 0) {
+      providerOptions.views = views;
+    }
+    this.provider = new import_sdk_metrics.MeterProvider(providerOptions);
+    import_api.default.metrics.setGlobalMeterProvider(this.provider);
   }
   getMeter(name, version) {
-    return this.provider.getMeter(name || this.meterName, version || this.version);
-  }
-  start() {
-    let readerName = this.readerName;
-    if (typeof readerName === "string") {
-      readerName = readerName.split(",");
+    if (!this.provider) {
+      return null;
     }
-    readerName.forEach((name) => {
-      const reader = this.getReader(name)();
-      this.provider.addMetricReader(reader);
-    });
+    return this.provider.getMeter(name || this.meterName, version || this.version);
   }
-  shutdown() {
-    return this.provider.shutdown();
+  async shutdown() {
+    var _a;
+    await Promise.all(this.activeReaders.map((r) => r.shutdown()));
+    await ((_a = this.provider) == null ? void 0 : _a.shutdown());
   }
 };
 __name(_Metric, "Metric");

package/lib/telemetry.d.ts

@@ -6,19 +6,21 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { InstrumentationOption } from '@opentelemetry/instrumentation';
+import { Instrumentation } from '@opentelemetry/instrumentation';
 import { Metric, MetricOptions } from './metric';
 import { Trace, TraceOptions } from './trace';
 export interface TelemetryOptions {
     serviceName?: string;
+    appName?: string;
     version?: string;
     trace?: TraceOptions;
     metric?: MetricOptions;
 }
 export declare class Telemetry {
     serviceName: string;
+    appName: string;
     version: string;
-    instrumentations: InstrumentationOption[];
+    instrumentations: Instrumentation[];
     trace: Trace;
     metric: Metric;
     started: boolean;
@@ -26,5 +28,5 @@ export declare class Telemetry {
     init(): void;
     start(): void;
     shutdown(): Promise<void>;
-    addInstrumentation(...instrumentation: InstrumentationOption[]): void;
+    addInstrumentation(...instrumentation: Instrumentation[]): void;
 }

package/lib/telemetry.js

@@ -37,28 +37,29 @@ var import_metric = require("./metric");
 var import_trace = require("./trace");
 const _Telemetry = class _Telemetry {
   serviceName;
+  appName;
   version;
   instrumentations = [];
   trace;
   metric;
   started = false;
   constructor(options) {
-    const { trace, metric, serviceName, version } = options || {};
+    const { trace, metric, serviceName, appName, version } = options || {};
     this.trace = new import_trace.Trace({ tracerName: `${serviceName}-trace`, version, ...trace });
     this.metric = new import_metric.Metric({ meterName: `${serviceName}-meter`, version, ...metric });
     this.serviceName = serviceName || "nocobase";
+    this.appName = appName;
     this.version = version || "";
   }
   init() {
     (0, import_instrumentation.registerInstrumentations)({
       instrumentations: this.instrumentations
     });
-    const resource = import_resources.Resource.default().merge(
-      new import_resources.Resource({
-        [import_semantic_conventions.SemanticResourceAttributes.SERVICE_NAME]: this.serviceName,
-        [import_semantic_conventions.SemanticResourceAttributes.SERVICE_VERSION]: this.version
-      })
-    );
+    const resource = (0, import_resources.resourceFromAttributes)({
+      [import_semantic_conventions.ATTR_SERVICE_NAME]: this.serviceName,
+      [import_semantic_conventions.ATTR_SERVICE_VERSION]: this.version,
+      "app.name": this.appName
+    });
     this.trace.init(resource);
     this.metric.init(resource);
   }

package/lib/trace.d.ts

@@ -21,13 +21,15 @@ export declare class Trace {
     processors: Registry<GetSpanProcessor>;
     tracerName: string;
     version: string;
-    provider: NodeTracerProvider;
+    provider?: NodeTracerProvider;
+    resource?: Resource;
+    activeProcessors: SpanProcessor[];
     constructor(options?: TraceOptions);
     init(resource: Resource): void;
     registerProcessor(name: string, processor: GetSpanProcessor): void;
     getProcessor(name: string): GetSpanProcessor;
-    getTracer(name?: string, version?: string): import("@opentelemetry/sdk-trace-base").Tracer;
     start(): void;
+    getTracer(name?: string, version?: string): import("@opentelemetry/api").Tracer;
     shutdown(): Promise<void>;
 }
 export {};

package/lib/trace.js

@@ -39,6 +39,8 @@ const _Trace = class _Trace {
   tracerName;
   version;
   provider;
+  resource;
+  activeProcessors = [];
   constructor(options) {
     const { processorName, tracerName, version } = options || {};
     this.processorName = processorName || "console";
@@ -47,10 +49,7 @@ const _Trace = class _Trace {
     this.registerProcessor("console", () => new import_sdk_trace_base.BatchSpanProcessor(new import_sdk_trace_base.ConsoleSpanExporter()));
   }
   init(resource) {
-    this.provider = new import_sdk_trace_node.NodeTracerProvider({
-      resource
-    });
-    this.provider.register();
+    this.resource = resource;
   }
   registerProcessor(name, processor) {
     this.processors.register(name, processor);
@@ -58,21 +57,40 @@ const _Trace = class _Trace {
   getProcessor(name) {
     return this.processors.get(name);
   }
-  getTracer(name, version) {
-    return this.provider.getTracer(name || this.tracerName, version || this.version);
-  }
   start() {
-    let processorName = this.processorName;
-    if (typeof processorName === "string") {
-      processorName = processorName.split(",");
+    if (!this.resource) {
+      throw new Error("Trace.init(resource) must be called before start()");
+    }
+    let names = this.processorName;
+    if (typeof names === "string") {
+      names = names.split(",");
+    }
+    const processors = [];
+    for (const name of names) {
+      const processor = this.getProcessor(name);
+      if (!processor) {
+        continue;
+      }
+      processors.push(processor());
     }
-    processorName.forEach((name) => {
-      const processor = this.getProcessor(name)();
-      this.provider.addSpanProcessor(processor);
-    });
+    this.activeProcessors = processors;
+    const config = {
+      resource: this.resource,
+      spanProcessors: processors
+    };
+    this.provider = new import_sdk_trace_node.NodeTracerProvider(config);
+    this.provider.register();
+  }
+  getTracer(name, version) {
+    if (!this.provider) {
+      return null;
+    }
+    return this.provider.getTracer(name || this.tracerName, version || this.version);
   }
-  shutdown() {
-    return this.provider.shutdown();
+  async shutdown() {
+    var _a;
+    await Promise.all(this.activeProcessors.map((p) => p.shutdown()));
+    await ((_a = this.provider) == null ? void 0 : _a.shutdown());
   }
 };
 __name(_Trace, "Trace");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/telemetry",
-  "version": "2.0.0-alpha.5",
+  "version": "2.0.0-alpha.51",
   "description": "nocobase telemetry library",
   "license": "AGPL-3.0",
   "main": "./lib/index.js",
@@ -11,14 +11,14 @@
     "directory": "packages/telemetry"
   },
   "dependencies": {
-    "@nocobase/utils": "2.0.0-alpha.5",
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/instrumentation": "^0.46.0",
-    "@opentelemetry/resources": "^1.19.0",
-    "@opentelemetry/sdk-metrics": "^1.19.0",
-    "@opentelemetry/sdk-trace-base": "^1.19.0",
-    "@opentelemetry/sdk-trace-node": "^1.19.0",
-    "@opentelemetry/semantic-conventions": "^1.19.0"
+    "@nocobase/utils": "2.0.0-alpha.51",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/instrumentation": "^0.207.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@opentelemetry/sdk-metrics": "^2.2.0",
+    "@opentelemetry/sdk-trace-base": "^2.2.0",
+    "@opentelemetry/sdk-trace-node": "^2.2.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0"
   },
-  "gitHead": "943e035bbec27f9ecfe8ce8857955945f20976f3"
+  "gitHead": "a1e34dd97f370d54f3d80a6b83ab7ddb9c72dc18"
 }