Batch observer

examples/metrics/README.md

@@ -23,14 +23,16 @@ $ npm run start:observer
 ```
 
 ### Prometheus
-1. In prometheus search for "metric_observer"
+1. In prometheus search for "cpu_core_usage", "cpu_temp_per_app", "cpu_usage_per_app"
 
 ### Links
 1. Prometheus Scrape Endpoint http://localhost:9464/metrics
 2. Prometheus graph http://localhost:9090/graph
 
 ### Example
-<p align="center"><img src="metrics/observer.png"/></p>
+![Screenshot of the running example](metrics/observer.png)
+![Screenshot of the running example](metrics/observer_batch.png)
+![Screenshot of the running example](metrics/observer_batch2.png)
 
 ## Useful links
 - For more information on OpenTelemetry, visit: <https://opentelemetry.io/>

examples/metrics/metrics/observer.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { MeterProvider, MetricObservable } = require('@opentelemetry/metrics');
+const { MeterProvider } = require('@opentelemetry/metrics');
+const { ConsoleLogger, LogLevel } = require('@opentelemetry/core');
 const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');
 
 const exporter = new PrometheusExporter(
@@ -14,29 +15,75 @@ const exporter = new PrometheusExporter(
 
 const meter = new MeterProvider({
   exporter,
-  interval: 2000,
+  interval: 3000,
 }).getMeter('example-observer');
 
-const otelCpuUsage = meter.createObserver('metric_observer', {
+meter.createObserver('cpu_core_usage', {
   monotonic: false,
-  labelKeys: ['pid', 'core'],
-  description: 'Example of a observer',
+  labelKeys: ['core'],
+  description: 'Example of a sync observer with callback',
+}, (observerResult) => {
+  observerResult.observe(getRandomValue(), { core: '1' });
+  observerResult.observe(getRandomValue(), { core: '2' });
 });
 
-function getCpuUsage() {
-  return Math.random();
-}
+const tempMetric = meter.createObserver('cpu_temp_per_app', {
+  monotonic: false,
+  labelKeys: ['app', 'core'],
+  description: 'Example of batch observer',
+});
+
+const cpuUsageMetric = meter.createObserver('cpu_usage_per_app', {
+  monotonic: false,
+  labelKeys: ['app', 'core'],
+  description: 'Example of batch observer',
+});
 
-const observable = new MetricObservable();
+meter.createBatchObserver('metric_batch_observer', (observerBatchResult) => {
+    function someAsyncMetrics() {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          const stats = [
+            {
+              name: 'app1',
+              core1: { usage: getRandomValue(), temp: getRandomValue() * 100 },
+              core2: { usage: getRandomValue(), temp: getRandomValue() * 100 },
+            },
+            {
+              name: 'app2',
+              core1: { usage: getRandomValue(), temp: getRandomValue() * 100 },
+              core2: { usage: getRandomValue(), temp: getRandomValue() * 100 },
+            },
+          ];
+          resolve(stats);
+        }, 200);
+      });
+    }
 
-setInterval(() => {
-  observable.next(getCpuUsage());
-}, 5000);
+    Promise.all([
+      someAsyncMetrics(),
+      // simulate waiting
+      new Promise((resolve, reject) => {
+        setTimeout(resolve, 300);
+      }),
+    ]).then(([apps, waiting]) => {
+      apps.forEach(app => {
+        observerBatchResult.observe({ app: app.name, core: '1' }, [
+          tempMetric.observation(app.core1.temp),
+          cpuUsageMetric.observation(app.core1.usage),
+        ]);
+        observerBatchResult.observe({ app: app.name, core: '2' }, [
+          tempMetric.observation(app.core2.temp),
+          cpuUsageMetric.observation(app.core2.usage),
+        ]);
+      });
+    });
+  }, {
+    maxTimeoutUpdateMS: 500,
+    logger: new ConsoleLogger(LogLevel.DEBUG)
+  },
+);
 
-otelCpuUsage.setCallback((observerResult) => {
-  observerResult.observe(getCpuUsage, { pid: process.pid, core: '1' });
-  observerResult.observe(getCpuUsage, { pid: process.pid, core: '2' });
-  observerResult.observe(getCpuUsage, { pid: process.pid, core: '3' });
-  observerResult.observe(getCpuUsage, { pid: process.pid, core: '4' });
-  observerResult.observe(observable, { pid: process.pid, core: '5' });
-});
+function getRandomValue() {
+  return Math.random();
+}

examples/metrics/package.json

@@ -26,6 +26,7 @@
     "url": "https://github.com/open-telemetry/opentelemetry-js/issues"
   },
   "dependencies": {
+    "@opentelemetry/core": "^0.8.3",
     "@opentelemetry/exporter-prometheus": "^0.8.3",
     "@opentelemetry/metrics": "^0.8.3"
   },

examples/tracer-web/examples/xml-http-request/index.js

@@ -26,16 +26,19 @@ providerWithZone.register({
 
 const webTracerWithZone = providerWithZone.getTracer('example-tracer-web');
 
-const getData = (url) => new Promise((resolve, _reject) => {
+const getData = (url) => new Promise((resolve, reject) => {
   // eslint-disable-next-line no-undef
   const req = new XMLHttpRequest();
   req.open('GET', url, true);
   req.setRequestHeader('Content-Type', 'application/json');
   req.setRequestHeader('Accept', 'application/json');
-  req.send();
   req.onload = () => {
     resolve();
   };
+  req.onerror = () => {
+    reject();
+  };
+  req.send();
 });
 
 // example of keeping track of context between async operations
@@ -53,6 +56,9 @@ const prepareClickEvent = () => {
         getData(url1).then((_data) => {
           webTracerWithZone.getCurrentSpan().addEvent('fetching-span1-completed');
           span1.end();
+        }, ()=> {
+          webTracerWithZone.getCurrentSpan().addEvent('fetching-error');
+          span1.end();
         });
       });
     }

packages/opentelemetry-api/src/index.ts

@@ -22,13 +22,15 @@ export * from './context/propagation/NoopHttpTextPropagator';
 export * from './context/propagation/setter';
 export * from './correlation_context/CorrelationContext';
 export * from './correlation_context/EntryValue';
+export * from './metrics/BatchObserverResult';
 export * from './metrics/BoundInstrument';
 export * from './metrics/Meter';
 export * from './metrics/MeterProvider';
 export * from './metrics/Metric';
 export * from './metrics/MetricObservable';
 export * from './metrics/NoopMeter';
 export * from './metrics/NoopMeterProvider';
+export * from './metrics/Observation';
 export * from './metrics/ObserverResult';
 export * from './trace/attributes';
 export * from './trace/Event';

packages/opentelemetry-api/src/metrics/BatchObserverResult.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright 2020, OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Labels } from './Metric';
+import { Observation } from './Observation';
+
+/**
+ * Interface that is being used in callback function for Observer Metric
+ *     for batch
+ */
+export interface BatchObserverResult {
+  /**
+   * Used to observe (update) observations for certain labels
+   * @param labels
+   * @param observations
+   */
+  observe(labels: Labels, observations: Observation[]): void;
+}

packages/opentelemetry-api/src/metrics/Meter.ts

@@ -14,7 +14,16 @@
  * limitations under the License.
  */
 
-import { MetricOptions, Counter, ValueRecorder, Observer } from './Metric';
+import { BatchObserverResult } from './BatchObserverResult';
+import {
+  MetricOptions,
+  Counter,
+  ValueRecorder,
+  Observer,
+  BatchObserver,
+  BatchMetricOptions,
+} from './Metric';
+import { ObserverResult } from './ObserverResult';
 
 /**
  * An interface to allow the recording metrics.
@@ -44,6 +53,24 @@ export interface Meter {
    * Creates a new `Observer` metric.
    * @param name the name of the metric.
    * @param [options] the metric options.
+   * @param [callback] the observer callback
    */
-  createObserver(name: string, options?: MetricOptions): Observer;
+  createObserver(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observerResult: ObserverResult) => void
+  ): Observer;
+
+  /**
+   * Creates a new `BatchObserver` metric, can be used to update many metrics
+   * at the same time and when operations needs to be async
+   * @param name the name of the metric.
+   * @param callback the batch observer callback
+   * @param [options] the metric batch options.
+   */
+  createBatchObserver(
+    name: string,
+    callback: (batchObserverResult: BatchObserverResult) => void,
+    options?: BatchMetricOptions
+  ): BatchObserver;
 }

packages/opentelemetry-api/src/metrics/Metric.ts

@@ -16,8 +16,9 @@
 
 import { CorrelationContext } from '../correlation_context/CorrelationContext';
 import { SpanContext } from '../trace/span_context';
-import { ObserverResult } from './ObserverResult';
 import { BoundCounter, BoundValueRecorder } from './BoundInstrument';
+import { Observation } from './Observation';
+import { Logger } from '../common/Logger';
 
 /**
  * Options needed for metric creation
@@ -66,6 +67,18 @@ export interface MetricOptions {
    * @default {@link ValueType.DOUBLE}
    */
   valueType?: ValueType;
+
+  /**
+   * User provided logger.
+   */
+  logger?: Logger;
+}
+
+export interface BatchMetricOptions extends MetricOptions {
+  /**
+   * Indicates how long the batch metric should wait to update before cancel
+   */
+  maxTimeoutUpdateMS?: number;
 }
 
 /** The Type of value. It describes how the data is reported. */
@@ -150,15 +163,12 @@ export interface ValueRecorder extends UnboundMetric<BoundValueRecorder> {
 
 /** Base interface for the Observer metrics. */
 export interface Observer extends Metric {
-  /**
-   * Sets a callback where user can observe value for certain labels. The
-   * observers are called periodically to retrieve the value.
-   * @param callback a function that will be called once to set observers
-   *     for values
-   */
-  setCallback(callback: (observerResult: ObserverResult) => void): void;
+  observation: (value: number) => Observation;
 }
 
+/** Base interface for the Batch Observer metrics. */
+export type BatchObserver = Metric;
+
 /**
  * key-value pairs passed by the user.
  */

packages/opentelemetry-api/src/metrics/NoopMeter.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import { BatchObserverResult } from './BatchObserverResult';
 import { Meter } from './Meter';
 import {
   MetricOptions,
@@ -22,10 +23,12 @@ import {
   Counter,
   ValueRecorder,
   Observer,
+  BatchObserver,
 } from './Metric';
 import { BoundValueRecorder, BoundCounter } from './BoundInstrument';
 import { CorrelationContext } from '../correlation_context/CorrelationContext';
 import { SpanContext } from '../trace/span_context';
+import { Observation } from './Observation';
 import { ObserverResult } from './ObserverResult';
 
 /**
@@ -57,8 +60,25 @@ export class NoopMeter implements Meter {
    * Returns constant noop observer.
    * @param name the name of the metric.
    * @param [options] the metric options.
+   * @param [callback] the observer callback
    */
-  createObserver(name: string, options?: MetricOptions): Observer {
+  createObserver(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observerResult: ObserverResult) => void
+  ): Observer {
+    return NOOP_OBSERVER_METRIC;
+  }
+
+  /**
+   * Returns constant noop observer.
+   * @param name the name of the metric.
+   * @param callback
+   */
+  createBatchObserver(
+    name: string,
+    callback: (batchObserverResult: BatchObserverResult) => void
+  ): Observer {
     return NOOP_OBSERVER_METRIC;
   }
 }
@@ -69,6 +89,7 @@ export class NoopMetric<T> implements UnboundMetric<T> {
   constructor(instrument: T) {
     this._instrument = instrument;
   }
+
   /**
    * Returns a Bound Instrument associated with specified Labels.
    * It is recommended to keep a reference to the Bound Instrument instead of
@@ -122,9 +143,17 @@ export class NoopValueRecorderMetric extends NoopMetric<BoundValueRecorder>
 }
 
 export class NoopObserverMetric extends NoopMetric<void> implements Observer {
-  setCallback(callback: (observerResult: ObserverResult) => void): void {}
+  observation(): Observation {
+    return {
+      observer: this,
+      value: 0,
+    };
+  }
 }
 
+export class NoopBatchObserverMetric extends NoopMetric<void>
+  implements BatchObserver {}
+
 export class NoopBoundCounter implements BoundCounter {
   add(value: number): void {
     return;
@@ -151,3 +180,4 @@ export const NOOP_VALUE_RECORDER_METRIC = new NoopValueRecorderMetric(
 );
 
 export const NOOP_OBSERVER_METRIC = new NoopObserverMetric();
+export const NOOP_BATCH_OBSERVER_METRIC = new NoopBatchObserverMetric();