decocms 2.364.1 → 2.364.2

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/view/View.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright The 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 { PatternPredicate } from './Predicate';
+import { createMultiAttributesProcessor, createNoopAttributesProcessor, } from './AttributesProcessor';
+import { InstrumentSelector } from './InstrumentSelector';
+import { MeterSelector } from './MeterSelector';
+import { AggregationType, toAggregation, } from './AggregationOption';
+function isSelectorNotProvided(options) {
+    return (options.instrumentName == null &&
+        options.instrumentType == null &&
+        options.instrumentUnit == null &&
+        options.meterName == null &&
+        options.meterVersion == null &&
+        options.meterSchemaUrl == null);
+}
+function validateViewOptions(viewOptions) {
+    // If no criteria is provided, the SDK SHOULD treat it as an error.
+    // It is recommended that the SDK implementations fail fast.
+    if (isSelectorNotProvided(viewOptions)) {
+        throw new Error('Cannot create view with no selector arguments supplied');
+    }
+    // the SDK SHOULD NOT allow Views with a specified name to be declared with instrument selectors that
+    // may select more than one instrument (e.g. wild card instrument name) in the same Meter.
+    if (viewOptions.name != null &&
+        (viewOptions?.instrumentName == null ||
+            PatternPredicate.hasWildcard(viewOptions.instrumentName))) {
+        throw new Error('Views with a specified name must be declared with an instrument selector that selects at most one instrument per meter.');
+    }
+}
+/**
+ * Can be passed to a {@link MeterProvider} to select instruments and alter their metric stream.
+ */
+export class View {
+    name;
+    description;
+    aggregation;
+    attributesProcessor;
+    instrumentSelector;
+    meterSelector;
+    aggregationCardinalityLimit;
+    /**
+     * Create a new {@link View} instance.
+     *
+     * Parameters can be categorized as two types:
+     *  Instrument selection criteria: Used to describe the instrument(s) this view will be applied to.
+     *  Will be treated as additive (the Instrument has to meet all the provided criteria to be selected).
+     *
+     *  Metric stream altering: Alter the metric stream of instruments selected by instrument selection criteria.
+     *
+     * @param viewOptions {@link ViewOptions} for altering the metric stream and instrument selection.
+     * @param viewOptions.name
+     * Alters the metric stream:
+     *  This will be used as the name of the metrics stream.
+     *  If not provided, the original Instrument name will be used.
+     * @param viewOptions.description
+     * Alters the metric stream:
+     *  This will be used as the description of the metrics stream.
+     *  If not provided, the original Instrument description will be used by default.
+     * @param viewOptions.attributesProcessors
+     * Alters the metric stream:
+     *  If provided, the attributes will be modified as defined by the added processors.
+     *  If not provided, all attribute keys will be used by default.
+     * @param viewOptions.aggregationCardinalityLimit
+     * Alters the metric stream:
+     *  Sets a limit on the number of unique attribute combinations (cardinality) that can be aggregated.
+     *  If not provided, the default limit of 2000 will be used.
+     * @param viewOptions.aggregation
+     * Alters the metric stream:
+     *  Alters the {@link Aggregation} of the metric stream.
+     * @param viewOptions.instrumentName
+     * Instrument selection criteria:
+     *  Original name of the Instrument(s) with wildcard support.
+     * @param viewOptions.instrumentType
+     * Instrument selection criteria:
+     *  The original type of the Instrument(s).
+     * @param viewOptions.instrumentUnit
+     * Instrument selection criteria:
+     *  The unit of the Instrument(s).
+     * @param viewOptions.meterName
+     * Instrument selection criteria:
+     *  The name of the Meter. No wildcard support, name must match the meter exactly.
+     * @param viewOptions.meterVersion
+     * Instrument selection criteria:
+     *  The version of the Meter. No wildcard support, version must match exactly.
+     * @param viewOptions.meterSchemaUrl
+     * Instrument selection criteria:
+     *  The schema URL of the Meter. No wildcard support, schema URL must match exactly.
+     *
+     * @example
+     * // Create a view that changes the Instrument 'my.instrument' to use to an
+     * // ExplicitBucketHistogramAggregation with the boundaries [20, 30, 40]
+     * new View({
+     *   aggregation: new ExplicitBucketHistogramAggregation([20, 30, 40]),
+     *   instrumentName: 'my.instrument'
+     * })
+     */
+    constructor(viewOptions) {
+        validateViewOptions(viewOptions);
+        // Create multi-processor if attributesProcessors are defined.
+        if (viewOptions.attributesProcessors != null) {
+            this.attributesProcessor = createMultiAttributesProcessor(viewOptions.attributesProcessors);
+        }
+        else {
+            this.attributesProcessor = createNoopAttributesProcessor();
+        }
+        this.name = viewOptions.name;
+        this.description = viewOptions.description;
+        this.aggregation = toAggregation(viewOptions.aggregation ?? { type: AggregationType.DEFAULT });
+        this.instrumentSelector = new InstrumentSelector({
+            name: viewOptions.instrumentName,
+            type: viewOptions.instrumentType,
+            unit: viewOptions.instrumentUnit,
+        });
+        this.meterSelector = new MeterSelector({
+            name: viewOptions.meterName,
+            version: viewOptions.meterVersion,
+            schemaUrl: viewOptions.meterSchemaUrl,
+        });
+        this.aggregationCardinalityLimit = viewOptions.aggregationCardinalityLimit;
+    }
+}
+//# sourceMappingURL=View.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/view/View.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"View.js","sourceRoot":"","sources":["../../../src/view/View.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,GAE9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAEL,eAAe,EACf,aAAa,GACd,MAAM,qBAAqB,CAAC;AA4G7B,SAAS,qBAAqB,CAAC,OAAoB;IACjD,OAAO,CACL,OAAO,CAAC,cAAc,IAAI,IAAI;QAC9B,OAAO,CAAC,cAAc,IAAI,IAAI;QAC9B,OAAO,CAAC,cAAc,IAAI,IAAI;QAC9B,OAAO,CAAC,SAAS,IAAI,IAAI;QACzB,OAAO,CAAC,YAAY,IAAI,IAAI;QAC5B,OAAO,CAAC,cAAc,IAAI,IAAI,CAC/B,CAAC;AACJ,CAAC;AAED,SAAS,mBAAmB,CAAC,WAAwB;IACnD,mEAAmE;IACnE,4DAA4D;IAC5D,IAAI,qBAAqB,CAAC,WAAW,CAAC,EAAE;QACtC,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC3E;IAED,qGAAqG;IACrG,0FAA0F;IAC1F,IACE,WAAW,CAAC,IAAI,IAAI,IAAI;QACxB,CAAC,WAAW,EAAE,cAAc,IAAI,IAAI;YAClC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,EAC3D;QACA,MAAM,IAAI,KAAK,CACb,yHAAyH,CAC1H,CAAC;KACH;AACH,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,IAAI;IACN,IAAI,CAAU;IACd,WAAW,CAAU;IACrB,WAAW,CAAc;IACzB,mBAAmB,CAAuB;IAC1C,kBAAkB,CAAqB;IACvC,aAAa,CAAgB;IAC7B,2BAA2B,CAAU;IAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,YAAY,WAAwB;QAClC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAEjC,8DAA8D;QAC9D,IAAI,WAAW,CAAC,oBAAoB,IAAI,IAAI,EAAE;YAC5C,IAAI,CAAC,mBAAmB,GAAG,8BAA8B,CACvD,WAAW,CAAC,oBAAoB,CACjC,CAAC;SACH;aAAM;YACL,IAAI,CAAC,mBAAmB,GAAG,6BAA6B,EAAE,CAAC;SAC5D;QAED,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;QAC3C,IAAI,CAAC,WAAW,GAAG,aAAa,CAC9B,WAAW,CAAC,WAAW,IAAI,EAAE,IAAI,EAAE,eAAe,CAAC,OAAO,EAAE,CAC7D,CAAC;QACF,IAAI,CAAC,kBAAkB,GAAG,IAAI,kBAAkB,CAAC;YAC/C,IAAI,EAAE,WAAW,CAAC,cAAc;YAChC,IAAI,EAAE,WAAW,CAAC,cAAc;YAChC,IAAI,EAAE,WAAW,CAAC,cAAc;SACjC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC;YACrC,IAAI,EAAE,WAAW,CAAC,SAAS;YAC3B,OAAO,EAAE,WAAW,CAAC,YAAY;YACjC,SAAS,EAAE,WAAW,CAAC,cAAc;SACtC,CAAC,CAAC;QACH,IAAI,CAAC,2BAA2B,GAAG,WAAW,CAAC,2BAA2B,CAAC;IAC7E,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PatternPredicate } from './Predicate';\nimport {\n  createMultiAttributesProcessor,\n  createNoopAttributesProcessor,\n  IAttributesProcessor,\n} from './AttributesProcessor';\nimport { InstrumentSelector } from './InstrumentSelector';\nimport { MeterSelector } from './MeterSelector';\nimport { Aggregation } from './Aggregation';\nimport {\n  AggregationOption,\n  AggregationType,\n  toAggregation,\n} from './AggregationOption';\nimport { InstrumentType } from '../export/MetricData';\n\nexport type ViewOptions = {\n  /**\n   *  Alters the metric stream:\n   *  This will be used as the name of the metrics stream.\n   *  If not provided, the original Instrument name will be used.\n   */\n  name?: string;\n  /**\n   * Alters the metric stream:\n   * This will be used as the description of the metrics stream.\n   * If not provided, the original Instrument description will be used by default.\n   *\n   * @example <caption>changes the description of all selected instruments to 'sample description'</caption>\n   * description: 'sample description'\n   */\n  description?: string;\n  /**\n   * Alters the metric stream:\n   * If provided, the attributes will be modified as defined by the processors in the list. Processors are applied\n   * in the order they're provided.\n   * If not provided, all attribute keys will be used by default.\n   *\n   * @example <caption>drops all attributes with top-level keys except for 'myAttr' and 'myOtherAttr'</caption>\n   * attributesProcessors: [createAllowListProcessor(['myAttr', 'myOtherAttr'])]\n   * @example <caption>drops all attributes</caption>\n   * attributesProcessors: [createAllowListProcessor([])]\n   * @example <caption>allows all attributes except for 'myAttr'</caption>\n   * attributesProcessors: [createDenyListProcessor(['myAttr']]\n   */\n  attributesProcessors?: IAttributesProcessor[];\n  /**\n   * Alters the metric stream:\n   * Alters the Aggregation of the metric stream.\n   *\n   * @example <caption>changes the aggregation of the selected instrument(s) to ExplicitBucketHistogramAggregation</caption>\n   * aggregation: { type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM, options: { boundaries: [1, 10, 100] } }\n   * @example <caption>changes the aggregation of the selected instrument(s) to LastValueAggregation</caption>\n   * aggregation: { type: AggregationType.LAST_VALUE, options: { boundaries: [1, 10, 100] } }\n   */\n  aggregation?: AggregationOption;\n  /**\n   * Alters the metric stream:\n   * Sets a limit on the number of unique attribute combinations (cardinality) that can be aggregated.\n   * If not provided, the default limit will be used.\n   *\n   * @example <caption>sets the cardinality limit to 1000</caption>\n   * aggregationCardinalityLimit: 1000\n   */\n  aggregationCardinalityLimit?: number;\n  /**\n   * Instrument selection criteria:\n   * The original type of the Instrument(s).\n   *\n   * @example <caption>selects all counters</caption>\n   * instrumentType: InstrumentType.COUNTER\n   * @example <caption>selects all histograms</caption>\n   * instrumentType: InstrumentType.HISTOGRAM\n   */\n  instrumentType?: InstrumentType;\n  /**\n   * Instrument selection criteria:\n   * Original name of the Instrument(s) with wildcard support.\n   *\n   * @example <caption>select all instruments</caption>\n   * instrumentName: '*'\n   * @example <caption>select all instruments starting with 'my.instruments.'</caption>\n   * instrumentName: 'my.instruments.*'\n   * @example <caption>select all instruments named 'my.instrument.requests' exactly</caption>\n   * instrumentName: 'my.instruments.requests'\n   */\n  instrumentName?: string;\n  /**\n   * Instrument selection criteria:\n   * The unit of the Instrument(s).\n   *\n   * @example <caption>select all instruments with unit 'ms'</caption>\n   * instrumentUnit: 'ms'\n   */\n  instrumentUnit?: string;\n  /**\n   * Instrument selection criteria:\n   * The name of the Meter. No wildcard support, name must match the meter exactly.\n   *\n   * @example <caption>select all meters named 'example.component.app' exactly</caption>\n   * meterName: 'example.component.app'\n   */\n  meterName?: string;\n  /**\n   * Instrument selection criteria:\n   * The version of the Meter. No wildcard support, version must match exactly.\n   *\n   * @example\n   * meterVersion: '1.0.1'\n   */\n  meterVersion?: string;\n  /**\n   * Instrument selection criteria:\n   * The schema URL of the Meter. No wildcard support, schema URL must match exactly.\n   *\n   * @example <caption>Select all meters with schema URL 'https://example.com/schema' exactly.</caption>\n   * meterSchemaUrl: 'https://example.com/schema'\n   */\n  meterSchemaUrl?: string;\n};\n\nfunction isSelectorNotProvided(options: ViewOptions): boolean {\n  return (\n    options.instrumentName == null &&\n    options.instrumentType == null &&\n    options.instrumentUnit == null &&\n    options.meterName == null &&\n    options.meterVersion == null &&\n    options.meterSchemaUrl == null\n  );\n}\n\nfunction validateViewOptions(viewOptions: ViewOptions) {\n  // If no criteria is provided, the SDK SHOULD treat it as an error.\n  // It is recommended that the SDK implementations fail fast.\n  if (isSelectorNotProvided(viewOptions)) {\n    throw new Error('Cannot create view with no selector arguments supplied');\n  }\n\n  // the SDK SHOULD NOT allow Views with a specified name to be declared with instrument selectors that\n  // may select more than one instrument (e.g. wild card instrument name) in the same Meter.\n  if (\n    viewOptions.name != null &&\n    (viewOptions?.instrumentName == null ||\n      PatternPredicate.hasWildcard(viewOptions.instrumentName))\n  ) {\n    throw new Error(\n      'Views with a specified name must be declared with an instrument selector that selects at most one instrument per meter.'\n    );\n  }\n}\n\n/**\n * Can be passed to a {@link MeterProvider} to select instruments and alter their metric stream.\n */\nexport class View {\n  readonly name?: string;\n  readonly description?: string;\n  readonly aggregation: Aggregation;\n  readonly attributesProcessor: IAttributesProcessor;\n  readonly instrumentSelector: InstrumentSelector;\n  readonly meterSelector: MeterSelector;\n  readonly aggregationCardinalityLimit?: number;\n\n  /**\n   * Create a new {@link View} instance.\n   *\n   * Parameters can be categorized as two types:\n   *  Instrument selection criteria: Used to describe the instrument(s) this view will be applied to.\n   *  Will be treated as additive (the Instrument has to meet all the provided criteria to be selected).\n   *\n   *  Metric stream altering: Alter the metric stream of instruments selected by instrument selection criteria.\n   *\n   * @param viewOptions {@link ViewOptions} for altering the metric stream and instrument selection.\n   * @param viewOptions.name\n   * Alters the metric stream:\n   *  This will be used as the name of the metrics stream.\n   *  If not provided, the original Instrument name will be used.\n   * @param viewOptions.description\n   * Alters the metric stream:\n   *  This will be used as the description of the metrics stream.\n   *  If not provided, the original Instrument description will be used by default.\n   * @param viewOptions.attributesProcessors\n   * Alters the metric stream:\n   *  If provided, the attributes will be modified as defined by the added processors.\n   *  If not provided, all attribute keys will be used by default.\n   * @param viewOptions.aggregationCardinalityLimit\n   * Alters the metric stream:\n   *  Sets a limit on the number of unique attribute combinations (cardinality) that can be aggregated.\n   *  If not provided, the default limit of 2000 will be used.\n   * @param viewOptions.aggregation\n   * Alters the metric stream:\n   *  Alters the {@link Aggregation} of the metric stream.\n   * @param viewOptions.instrumentName\n   * Instrument selection criteria:\n   *  Original name of the Instrument(s) with wildcard support.\n   * @param viewOptions.instrumentType\n   * Instrument selection criteria:\n   *  The original type of the Instrument(s).\n   * @param viewOptions.instrumentUnit\n   * Instrument selection criteria:\n   *  The unit of the Instrument(s).\n   * @param viewOptions.meterName\n   * Instrument selection criteria:\n   *  The name of the Meter. No wildcard support, name must match the meter exactly.\n   * @param viewOptions.meterVersion\n   * Instrument selection criteria:\n   *  The version of the Meter. No wildcard support, version must match exactly.\n   * @param viewOptions.meterSchemaUrl\n   * Instrument selection criteria:\n   *  The schema URL of the Meter. No wildcard support, schema URL must match exactly.\n   *\n   * @example\n   * // Create a view that changes the Instrument 'my.instrument' to use to an\n   * // ExplicitBucketHistogramAggregation with the boundaries [20, 30, 40]\n   * new View({\n   *   aggregation: new ExplicitBucketHistogramAggregation([20, 30, 40]),\n   *   instrumentName: 'my.instrument'\n   * })\n   */\n  constructor(viewOptions: ViewOptions) {\n    validateViewOptions(viewOptions);\n\n    // Create multi-processor if attributesProcessors are defined.\n    if (viewOptions.attributesProcessors != null) {\n      this.attributesProcessor = createMultiAttributesProcessor(\n        viewOptions.attributesProcessors\n      );\n    } else {\n      this.attributesProcessor = createNoopAttributesProcessor();\n    }\n\n    this.name = viewOptions.name;\n    this.description = viewOptions.description;\n    this.aggregation = toAggregation(\n      viewOptions.aggregation ?? { type: AggregationType.DEFAULT }\n    );\n    this.instrumentSelector = new InstrumentSelector({\n      name: viewOptions.instrumentName,\n      type: viewOptions.instrumentType,\n      unit: viewOptions.instrumentUnit,\n    });\n    this.meterSelector = new MeterSelector({\n      name: viewOptions.meterName,\n      version: viewOptions.meterVersion,\n      schemaUrl: viewOptions.meterSchemaUrl,\n    });\n    this.aggregationCardinalityLimit = viewOptions.aggregationCardinalityLimit;\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/view/ViewRegistry.d.ts

@@ -0,0 +1,11 @@
+import { InstrumentationScope } from '@opentelemetry/core';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { View } from './View';
+export declare class ViewRegistry {
+    private _registeredViews;
+    addView(view: View): void;
+    findViews(instrument: InstrumentDescriptor, meter: InstrumentationScope): View[];
+    private _matchInstrument;
+    private _matchMeter;
+}
+//# sourceMappingURL=ViewRegistry.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/view/ViewRegistry.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright The 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.
+ */
+export class ViewRegistry {
+    _registeredViews = [];
+    addView(view) {
+        this._registeredViews.push(view);
+    }
+    findViews(instrument, meter) {
+        const views = this._registeredViews.filter(registeredView => {
+            return (this._matchInstrument(registeredView.instrumentSelector, instrument) &&
+                this._matchMeter(registeredView.meterSelector, meter));
+        });
+        return views;
+    }
+    _matchInstrument(selector, instrument) {
+        return ((selector.getType() === undefined ||
+            instrument.type === selector.getType()) &&
+            selector.getNameFilter().match(instrument.name) &&
+            selector.getUnitFilter().match(instrument.unit));
+    }
+    _matchMeter(selector, meter) {
+        return (selector.getNameFilter().match(meter.name) &&
+            (meter.version === undefined ||
+                selector.getVersionFilter().match(meter.version)) &&
+            (meter.schemaUrl === undefined ||
+                selector.getSchemaUrlFilter().match(meter.schemaUrl)));
+    }
+}
+//# sourceMappingURL=ViewRegistry.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/view/ViewRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewRegistry.js","sourceRoot":"","sources":["../../../src/view/ViewRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,MAAM,OAAO,YAAY;IACf,gBAAgB,GAAW,EAAE,CAAC;IAEtC,OAAO,CAAC,IAAU;QAChB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,SAAS,CACP,UAAgC,EAChC,KAA2B;QAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE;YAC1D,OAAO,CACL,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,kBAAkB,EAAE,UAAU,CAAC;gBACpE,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACtD,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,gBAAgB,CACtB,QAA4B,EAC5B,UAAgC;QAEhC,OAAO,CACL,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,SAAS;YAC/B,UAAU,CAAC,IAAI,KAAK,QAAQ,CAAC,OAAO,EAAE,CAAC;YACzC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;YAC/C,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAChD,CAAC;IACJ,CAAC;IAEO,WAAW,CACjB,QAAuB,EACvB,KAA2B;QAE3B,OAAO,CACL,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1C,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS;gBAC1B,QAAQ,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACnD,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS;gBAC5B,QAAQ,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CACxD,CAAC;IACJ,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { InstrumentationScope } from '@opentelemetry/core';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\nimport { InstrumentSelector } from './InstrumentSelector';\nimport { MeterSelector } from './MeterSelector';\nimport { View } from './View';\n\nexport class ViewRegistry {\n  private _registeredViews: View[] = [];\n\n  addView(view: View) {\n    this._registeredViews.push(view);\n  }\n\n  findViews(\n    instrument: InstrumentDescriptor,\n    meter: InstrumentationScope\n  ): View[] {\n    const views = this._registeredViews.filter(registeredView => {\n      return (\n        this._matchInstrument(registeredView.instrumentSelector, instrument) &&\n        this._matchMeter(registeredView.meterSelector, meter)\n      );\n    });\n\n    return views;\n  }\n\n  private _matchInstrument(\n    selector: InstrumentSelector,\n    instrument: InstrumentDescriptor\n  ): boolean {\n    return (\n      (selector.getType() === undefined ||\n        instrument.type === selector.getType()) &&\n      selector.getNameFilter().match(instrument.name) &&\n      selector.getUnitFilter().match(instrument.unit)\n    );\n  }\n\n  private _matchMeter(\n    selector: MeterSelector,\n    meter: InstrumentationScope\n  ): boolean {\n    return (\n      selector.getNameFilter().match(meter.name) &&\n      (meter.version === undefined ||\n        selector.getVersionFilter().match(meter.version)) &&\n      (meter.schemaUrl === undefined ||\n        selector.getSchemaUrlFilter().match(meter.schemaUrl))\n    );\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/InstrumentDescriptor.d.ts

@@ -0,0 +1,27 @@
+import { MetricAdvice, MetricOptions } from '@opentelemetry/api';
+import { View } from './view/View';
+import { InstrumentType, MetricDescriptor } from './export/MetricData';
+/**
+ * An internal interface describing the instrument.
+ *
+ * This is intentionally distinguished from the public MetricDescriptor (a.k.a. InstrumentDescriptor)
+ * which may not contains internal fields like metric advice.
+ */
+export interface InstrumentDescriptor extends MetricDescriptor {
+    /**
+     * For internal use; exporter should avoid depending on the type of the
+     * instrument as their resulting aggregator can be re-mapped with views.
+     */
+    readonly type: InstrumentType;
+    /**
+     * See {@link MetricAdvice}
+     *
+     * @experimental
+     */
+    readonly advice: MetricAdvice;
+}
+export declare function createInstrumentDescriptor(name: string, type: InstrumentType, options?: MetricOptions): InstrumentDescriptor;
+export declare function createInstrumentDescriptorWithView(view: View, instrument: InstrumentDescriptor): InstrumentDescriptor;
+export declare function isDescriptorCompatibleWith(descriptor: InstrumentDescriptor, otherDescriptor: InstrumentDescriptor): boolean;
+export declare function isValidName(name: string): boolean;
+//# sourceMappingURL=InstrumentDescriptor.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/InstrumentDescriptor.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright The 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 { ValueType, diag, } from '@opentelemetry/api';
+import { equalsCaseInsensitive } from './utils';
+export function createInstrumentDescriptor(name, type, options) {
+    if (!isValidName(name)) {
+        diag.warn(`Invalid metric name: "${name}". The metric name should be a ASCII string with a length no greater than 255 characters.`);
+    }
+    return {
+        name,
+        type,
+        description: options?.description ?? '',
+        unit: options?.unit ?? '',
+        valueType: options?.valueType ?? ValueType.DOUBLE,
+        advice: options?.advice ?? {},
+    };
+}
+export function createInstrumentDescriptorWithView(view, instrument) {
+    return {
+        name: view.name ?? instrument.name,
+        description: view.description ?? instrument.description,
+        type: instrument.type,
+        unit: instrument.unit,
+        valueType: instrument.valueType,
+        advice: instrument.advice,
+    };
+}
+export function isDescriptorCompatibleWith(descriptor, otherDescriptor) {
+    // Names are case-insensitive strings.
+    return (equalsCaseInsensitive(descriptor.name, otherDescriptor.name) &&
+        descriptor.unit === otherDescriptor.unit &&
+        descriptor.type === otherDescriptor.type &&
+        descriptor.valueType === otherDescriptor.valueType);
+}
+// ASCII string with a length no greater than 255 characters.
+// NB: the first character counted separately from the rest.
+const NAME_REGEXP = /^[a-z][a-z0-9_.\-/]{0,254}$/i;
+export function isValidName(name) {
+    return NAME_REGEXP.test(name);
+}
+//# sourceMappingURL=InstrumentDescriptor.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/InstrumentDescriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstrumentDescriptor.js","sourceRoot":"","sources":["../../src/InstrumentDescriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAGL,SAAS,EACT,IAAI,GACL,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAwBhD,MAAM,UAAU,0BAA0B,CACxC,IAAY,EACZ,IAAoB,EACpB,OAAuB;IAEvB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;QACtB,IAAI,CAAC,IAAI,CACP,yBAAyB,IAAI,2FAA2F,CACzH,CAAC;KACH;IACD,OAAO;QACL,IAAI;QACJ,IAAI;QACJ,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,EAAE;QACvC,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE;QACzB,SAAS,EAAE,OAAO,EAAE,SAAS,IAAI,SAAS,CAAC,MAAM;QACjD,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,EAAE;KAC9B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kCAAkC,CAChD,IAAU,EACV,UAAgC;IAEhC,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI;QAClC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,UAAU,CAAC,WAAW;QACvD,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,SAAS,EAAE,UAAU,CAAC,SAAS;QAC/B,MAAM,EAAE,UAAU,CAAC,MAAM;KAC1B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,UAAgC,EAChC,eAAqC;IAErC,sCAAsC;IACtC,OAAO,CACL,qBAAqB,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC;QAC5D,UAAU,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI;QACxC,UAAU,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI;QACxC,UAAU,CAAC,SAAS,KAAK,eAAe,CAAC,SAAS,CACnD,CAAC;AACJ,CAAC;AAED,6DAA6D;AAC7D,4DAA4D;AAC5D,MAAM,WAAW,GAAG,8BAA8B,CAAC;AACnD,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  MetricAdvice,\n  MetricOptions,\n  ValueType,\n  diag,\n} from '@opentelemetry/api';\nimport { View } from './view/View';\nimport { equalsCaseInsensitive } from './utils';\nimport { InstrumentType, MetricDescriptor } from './export/MetricData';\n\n/**\n * An internal interface describing the instrument.\n *\n * This is intentionally distinguished from the public MetricDescriptor (a.k.a. InstrumentDescriptor)\n * which may not contains internal fields like metric advice.\n */\nexport interface InstrumentDescriptor extends MetricDescriptor {\n  /**\n   * For internal use; exporter should avoid depending on the type of the\n   * instrument as their resulting aggregator can be re-mapped with views.\n   */\n  readonly type: InstrumentType;\n\n  /**\n   * See {@link MetricAdvice}\n   *\n   * @experimental\n   */\n  readonly advice: MetricAdvice;\n}\n\nexport function createInstrumentDescriptor(\n  name: string,\n  type: InstrumentType,\n  options?: MetricOptions\n): InstrumentDescriptor {\n  if (!isValidName(name)) {\n    diag.warn(\n      `Invalid metric name: \"${name}\". The metric name should be a ASCII string with a length no greater than 255 characters.`\n    );\n  }\n  return {\n    name,\n    type,\n    description: options?.description ?? '',\n    unit: options?.unit ?? '',\n    valueType: options?.valueType ?? ValueType.DOUBLE,\n    advice: options?.advice ?? {},\n  };\n}\n\nexport function createInstrumentDescriptorWithView(\n  view: View,\n  instrument: InstrumentDescriptor\n): InstrumentDescriptor {\n  return {\n    name: view.name ?? instrument.name,\n    description: view.description ?? instrument.description,\n    type: instrument.type,\n    unit: instrument.unit,\n    valueType: instrument.valueType,\n    advice: instrument.advice,\n  };\n}\n\nexport function isDescriptorCompatibleWith(\n  descriptor: InstrumentDescriptor,\n  otherDescriptor: InstrumentDescriptor\n) {\n  // Names are case-insensitive strings.\n  return (\n    equalsCaseInsensitive(descriptor.name, otherDescriptor.name) &&\n    descriptor.unit === otherDescriptor.unit &&\n    descriptor.type === otherDescriptor.type &&\n    descriptor.valueType === otherDescriptor.valueType\n  );\n}\n\n// ASCII string with a length no greater than 255 characters.\n// NB: the first character counted separately from the rest.\nconst NAME_REGEXP = /^[a-z][a-z0-9_.\\-/]{0,254}$/i;\nexport function isValidName(name: string): boolean {\n  return NAME_REGEXP.test(name);\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/Instruments.d.ts

@@ -0,0 +1,70 @@
+import { Context, Attributes, UpDownCounter, Counter, Gauge, Histogram, Observable, ObservableCallback, ObservableCounter, ObservableGauge, ObservableUpDownCounter } from '@opentelemetry/api';
+import { InstrumentDescriptor } from './InstrumentDescriptor';
+import { ObservableRegistry } from './state/ObservableRegistry';
+import { AsyncWritableMetricStorage, WritableMetricStorage } from './state/WritableMetricStorage';
+export declare class SyncInstrument {
+    private _writableMetricStorage;
+    protected _descriptor: InstrumentDescriptor;
+    constructor(writableMetricStorage: WritableMetricStorage, descriptor: InstrumentDescriptor);
+    protected _record(value: number, attributes?: Attributes, context?: Context): void;
+}
+/**
+ * The class implements {@link UpDownCounter} interface.
+ */
+export declare class UpDownCounterInstrument extends SyncInstrument implements UpDownCounter {
+    /**
+     * Increment value of counter by the input. Inputs may be negative.
+     */
+    add(value: number, attributes?: Attributes, ctx?: Context): void;
+}
+/**
+ * The class implements {@link Counter} interface.
+ */
+export declare class CounterInstrument extends SyncInstrument implements Counter {
+    /**
+     * Increment value of counter by the input. Inputs may not be negative.
+     */
+    add(value: number, attributes?: Attributes, ctx?: Context): void;
+}
+/**
+ * The class implements {@link Gauge} interface.
+ */
+export declare class GaugeInstrument extends SyncInstrument implements Gauge {
+    /**
+     * Records a measurement.
+     */
+    record(value: number, attributes?: Attributes, ctx?: Context): void;
+}
+/**
+ * The class implements {@link Histogram} interface.
+ */
+export declare class HistogramInstrument extends SyncInstrument implements Histogram {
+    /**
+     * Records a measurement. Value of the measurement must not be negative.
+     */
+    record(value: number, attributes?: Attributes, ctx?: Context): void;
+}
+export declare class ObservableInstrument implements Observable {
+    /** @internal */
+    _metricStorages: AsyncWritableMetricStorage[];
+    /** @internal */
+    _descriptor: InstrumentDescriptor;
+    private _observableRegistry;
+    constructor(descriptor: InstrumentDescriptor, metricStorages: AsyncWritableMetricStorage[], observableRegistry: ObservableRegistry);
+    /**
+     * @see {Observable.addCallback}
+     */
+    addCallback(callback: ObservableCallback): void;
+    /**
+     * @see {Observable.removeCallback}
+     */
+    removeCallback(callback: ObservableCallback): void;
+}
+export declare class ObservableCounterInstrument extends ObservableInstrument implements ObservableCounter {
+}
+export declare class ObservableGaugeInstrument extends ObservableInstrument implements ObservableGauge {
+}
+export declare class ObservableUpDownCounterInstrument extends ObservableInstrument implements ObservableUpDownCounter {
+}
+export declare function isObservableInstrument(it: unknown): it is ObservableInstrument;
+//# sourceMappingURL=Instruments.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/Instruments.js

@@ -0,0 +1,127 @@
+/*
+ * Copyright The 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 { context as contextApi, diag, ValueType, } from '@opentelemetry/api';
+import { millisToHrTime } from '@opentelemetry/core';
+export class SyncInstrument {
+    _writableMetricStorage;
+    _descriptor;
+    constructor(writableMetricStorage, descriptor) {
+        this._writableMetricStorage = writableMetricStorage;
+        this._descriptor = descriptor;
+    }
+    _record(value, attributes = {}, context = contextApi.active()) {
+        if (typeof value !== 'number') {
+            diag.warn(`non-number value provided to metric ${this._descriptor.name}: ${value}`);
+            return;
+        }
+        if (this._descriptor.valueType === ValueType.INT &&
+            !Number.isInteger(value)) {
+            diag.warn(`INT value type cannot accept a floating-point value for ${this._descriptor.name}, ignoring the fractional digits.`);
+            value = Math.trunc(value);
+            // ignore non-finite values.
+            if (!Number.isInteger(value)) {
+                return;
+            }
+        }
+        this._writableMetricStorage.record(value, attributes, context, millisToHrTime(Date.now()));
+    }
+}
+/**
+ * The class implements {@link UpDownCounter} interface.
+ */
+export class UpDownCounterInstrument extends SyncInstrument {
+    /**
+     * Increment value of counter by the input. Inputs may be negative.
+     */
+    add(value, attributes, ctx) {
+        this._record(value, attributes, ctx);
+    }
+}
+/**
+ * The class implements {@link Counter} interface.
+ */
+export class CounterInstrument extends SyncInstrument {
+    /**
+     * Increment value of counter by the input. Inputs may not be negative.
+     */
+    add(value, attributes, ctx) {
+        if (value < 0) {
+            diag.warn(`negative value provided to counter ${this._descriptor.name}: ${value}`);
+            return;
+        }
+        this._record(value, attributes, ctx);
+    }
+}
+/**
+ * The class implements {@link Gauge} interface.
+ */
+export class GaugeInstrument extends SyncInstrument {
+    /**
+     * Records a measurement.
+     */
+    record(value, attributes, ctx) {
+        this._record(value, attributes, ctx);
+    }
+}
+/**
+ * The class implements {@link Histogram} interface.
+ */
+export class HistogramInstrument extends SyncInstrument {
+    /**
+     * Records a measurement. Value of the measurement must not be negative.
+     */
+    record(value, attributes, ctx) {
+        if (value < 0) {
+            diag.warn(`negative value provided to histogram ${this._descriptor.name}: ${value}`);
+            return;
+        }
+        this._record(value, attributes, ctx);
+    }
+}
+export class ObservableInstrument {
+    /** @internal */
+    _metricStorages;
+    /** @internal */
+    _descriptor;
+    _observableRegistry;
+    constructor(descriptor, metricStorages, observableRegistry) {
+        this._descriptor = descriptor;
+        this._metricStorages = metricStorages;
+        this._observableRegistry = observableRegistry;
+    }
+    /**
+     * @see {Observable.addCallback}
+     */
+    addCallback(callback) {
+        this._observableRegistry.addCallback(callback, this);
+    }
+    /**
+     * @see {Observable.removeCallback}
+     */
+    removeCallback(callback) {
+        this._observableRegistry.removeCallback(callback, this);
+    }
+}
+export class ObservableCounterInstrument extends ObservableInstrument {
+}
+export class ObservableGaugeInstrument extends ObservableInstrument {
+}
+export class ObservableUpDownCounterInstrument extends ObservableInstrument {
+}
+export function isObservableInstrument(it) {
+    return it instanceof ObservableInstrument;
+}
+//# sourceMappingURL=Instruments.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/Instruments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instruments.js","sourceRoot":"","sources":["../../src/Instruments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,OAAO,IAAI,UAAU,EACrB,IAAI,EAGJ,SAAS,GAUV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQrD,MAAM,OAAO,cAAc;IACjB,sBAAsB,CAAwB;IAC5C,WAAW,CAAuB;IAE5C,YACE,qBAA4C,EAC5C,UAAgC;QAEhC,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAES,OAAO,CACf,KAAa,EACb,aAAyB,EAAE,EAC3B,UAAmB,UAAU,CAAC,MAAM,EAAE;QAEtC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,IAAI,CAAC,IAAI,CACP,uCAAuC,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,EAAE,CACzE,CAAC;YACF,OAAO;SACR;QACD,IACE,IAAI,CAAC,WAAW,CAAC,SAAS,KAAK,SAAS,CAAC,GAAG;YAC5C,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EACxB;YACA,IAAI,CAAC,IAAI,CACP,2DAA2D,IAAI,CAAC,WAAW,CAAC,IAAI,mCAAmC,CACpH,CAAC;YACF,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,4BAA4B;YAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBAC5B,OAAO;aACR;SACF;QACD,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAChC,KAAK,EACL,UAAU,EACV,OAAO,EACP,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC3B,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,uBACX,SAAQ,cAAc;IAGtB;;OAEG;IACH,GAAG,CAAC,KAAa,EAAE,UAAuB,EAAE,GAAa;QACvD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,cAAc;IACnD;;OAEG;IACH,GAAG,CAAC,KAAa,EAAE,UAAuB,EAAE,GAAa;QACvD,IAAI,KAAK,GAAG,CAAC,EAAE;YACb,IAAI,CAAC,IAAI,CACP,sCAAsC,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,EAAE,CACxE,CAAC;YACF,OAAO;SACR;QAED,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,cAAc;IACjD;;OAEG;IACH,MAAM,CAAC,KAAa,EAAE,UAAuB,EAAE,GAAa;QAC1D,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,cAAc;IACrD;;OAEG;IACH,MAAM,CAAC,KAAa,EAAE,UAAuB,EAAE,GAAa;QAC1D,IAAI,KAAK,GAAG,CAAC,EAAE;YACb,IAAI,CAAC,IAAI,CACP,wCAAwC,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,EAAE,CAC1E,CAAC;YACF,OAAO;SACR;QACD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;CACF;AAED,MAAM,OAAO,oBAAoB;IAC/B,gBAAgB;IAChB,eAAe,CAA+B;IAC9C,gBAAgB;IAChB,WAAW,CAAuB;IAC1B,mBAAmB,CAAqB;IAEhD,YACE,UAAgC,EAChC,cAA4C,EAC5C,kBAAsC;QAEtC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,QAA4B;QACtC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,QAA4B;QACzC,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;CACF;AAED,MAAM,OAAO,2BACX,SAAQ,oBAAoB;CACG;AACjC,MAAM,OAAO,yBACX,SAAQ,oBAAoB;CACC;AAC/B,MAAM,OAAO,iCACX,SAAQ,oBAAoB;CACS;AAEvC,MAAM,UAAU,sBAAsB,CACpC,EAAW;IAEX,OAAO,EAAE,YAAY,oBAAoB,CAAC;AAC5C,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  context as contextApi,\n  diag,\n  Context,\n  Attributes,\n  ValueType,\n  UpDownCounter,\n  Counter,\n  Gauge,\n  Histogram,\n  Observable,\n  ObservableCallback,\n  ObservableCounter,\n  ObservableGauge,\n  ObservableUpDownCounter,\n} from '@opentelemetry/api';\nimport { millisToHrTime } from '@opentelemetry/core';\nimport { InstrumentDescriptor } from './InstrumentDescriptor';\nimport { ObservableRegistry } from './state/ObservableRegistry';\nimport {\n  AsyncWritableMetricStorage,\n  WritableMetricStorage,\n} from './state/WritableMetricStorage';\n\nexport class SyncInstrument {\n  private _writableMetricStorage: WritableMetricStorage;\n  protected _descriptor: InstrumentDescriptor;\n\n  constructor(\n    writableMetricStorage: WritableMetricStorage,\n    descriptor: InstrumentDescriptor\n  ) {\n    this._writableMetricStorage = writableMetricStorage;\n    this._descriptor = descriptor;\n  }\n\n  protected _record(\n    value: number,\n    attributes: Attributes = {},\n    context: Context = contextApi.active()\n  ) {\n    if (typeof value !== 'number') {\n      diag.warn(\n        `non-number value provided to metric ${this._descriptor.name}: ${value}`\n      );\n      return;\n    }\n    if (\n      this._descriptor.valueType === ValueType.INT &&\n      !Number.isInteger(value)\n    ) {\n      diag.warn(\n        `INT value type cannot accept a floating-point value for ${this._descriptor.name}, ignoring the fractional digits.`\n      );\n      value = Math.trunc(value);\n      // ignore non-finite values.\n      if (!Number.isInteger(value)) {\n        return;\n      }\n    }\n    this._writableMetricStorage.record(\n      value,\n      attributes,\n      context,\n      millisToHrTime(Date.now())\n    );\n  }\n}\n\n/**\n * The class implements {@link UpDownCounter} interface.\n */\nexport class UpDownCounterInstrument\n  extends SyncInstrument\n  implements UpDownCounter\n{\n  /**\n   * Increment value of counter by the input. Inputs may be negative.\n   */\n  add(value: number, attributes?: Attributes, ctx?: Context): void {\n    this._record(value, attributes, ctx);\n  }\n}\n\n/**\n * The class implements {@link Counter} interface.\n */\nexport class CounterInstrument extends SyncInstrument implements Counter {\n  /**\n   * Increment value of counter by the input. Inputs may not be negative.\n   */\n  add(value: number, attributes?: Attributes, ctx?: Context): void {\n    if (value < 0) {\n      diag.warn(\n        `negative value provided to counter ${this._descriptor.name}: ${value}`\n      );\n      return;\n    }\n\n    this._record(value, attributes, ctx);\n  }\n}\n\n/**\n * The class implements {@link Gauge} interface.\n */\nexport class GaugeInstrument extends SyncInstrument implements Gauge {\n  /**\n   * Records a measurement.\n   */\n  record(value: number, attributes?: Attributes, ctx?: Context): void {\n    this._record(value, attributes, ctx);\n  }\n}\n\n/**\n * The class implements {@link Histogram} interface.\n */\nexport class HistogramInstrument extends SyncInstrument implements Histogram {\n  /**\n   * Records a measurement. Value of the measurement must not be negative.\n   */\n  record(value: number, attributes?: Attributes, ctx?: Context): void {\n    if (value < 0) {\n      diag.warn(\n        `negative value provided to histogram ${this._descriptor.name}: ${value}`\n      );\n      return;\n    }\n    this._record(value, attributes, ctx);\n  }\n}\n\nexport class ObservableInstrument implements Observable {\n  /** @internal */\n  _metricStorages: AsyncWritableMetricStorage[];\n  /** @internal */\n  _descriptor: InstrumentDescriptor;\n  private _observableRegistry: ObservableRegistry;\n\n  constructor(\n    descriptor: InstrumentDescriptor,\n    metricStorages: AsyncWritableMetricStorage[],\n    observableRegistry: ObservableRegistry\n  ) {\n    this._descriptor = descriptor;\n    this._metricStorages = metricStorages;\n    this._observableRegistry = observableRegistry;\n  }\n\n  /**\n   * @see {Observable.addCallback}\n   */\n  addCallback(callback: ObservableCallback) {\n    this._observableRegistry.addCallback(callback, this);\n  }\n\n  /**\n   * @see {Observable.removeCallback}\n   */\n  removeCallback(callback: ObservableCallback) {\n    this._observableRegistry.removeCallback(callback, this);\n  }\n}\n\nexport class ObservableCounterInstrument\n  extends ObservableInstrument\n  implements ObservableCounter {}\nexport class ObservableGaugeInstrument\n  extends ObservableInstrument\n  implements ObservableGauge {}\nexport class ObservableUpDownCounterInstrument\n  extends ObservableInstrument\n  implements ObservableUpDownCounter {}\n\nexport function isObservableInstrument(\n  it: unknown\n): it is ObservableInstrument {\n  return it instanceof ObservableInstrument;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/Meter.d.ts

@@ -0,0 +1,46 @@
+import { Meter as IMeter, MetricOptions, Gauge, Histogram, Counter, UpDownCounter, ObservableGauge, ObservableCounter, ObservableUpDownCounter, BatchObservableCallback, Observable } from '@opentelemetry/api';
+import { MeterSharedState } from './state/MeterSharedState';
+/**
+ * This class implements the {@link IMeter} interface.
+ */
+export declare class Meter implements IMeter {
+    private _meterSharedState;
+    constructor(meterSharedState: MeterSharedState);
+    /**
+     * Create a {@link Gauge} instrument.
+     */
+    createGauge(name: string, options?: MetricOptions): Gauge;
+    /**
+     * Create a {@link Histogram} instrument.
+     */
+    createHistogram(name: string, options?: MetricOptions): Histogram;
+    /**
+     * Create a {@link Counter} instrument.
+     */
+    createCounter(name: string, options?: MetricOptions): Counter;
+    /**
+     * Create a {@link UpDownCounter} instrument.
+     */
+    createUpDownCounter(name: string, options?: MetricOptions): UpDownCounter;
+    /**
+     * Create a {@link ObservableGauge} instrument.
+     */
+    createObservableGauge(name: string, options?: MetricOptions): ObservableGauge;
+    /**
+     * Create a {@link ObservableCounter} instrument.
+     */
+    createObservableCounter(name: string, options?: MetricOptions): ObservableCounter;
+    /**
+     * Create a {@link ObservableUpDownCounter} instrument.
+     */
+    createObservableUpDownCounter(name: string, options?: MetricOptions): ObservableUpDownCounter;
+    /**
+     * @see {@link Meter.addBatchObservableCallback}
+     */
+    addBatchObservableCallback(callback: BatchObservableCallback, observables: Observable[]): void;
+    /**
+     * @see {@link Meter.removeBatchObservableCallback}
+     */
+    removeBatchObservableCallback(callback: BatchObservableCallback, observables: Observable[]): void;
+}
+//# sourceMappingURL=Meter.d.ts.map