diff --git a/package.json b/package.json index a96f88d8a69..7a4e9ac9dbd 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,9 @@ "docs": "lerna run docs", "docs-deploy": "gh-pages --dist packages/opentelemetry-api/docs/out", "lint": "lerna run lint", + "lint:changed": "lerna run --concurrency 1 --stream lint --since HEAD --exclude-dependents", "lint:fix": "lerna run lint:fix", + "lint:fix:changed": "lerna run --concurrency 1 --stream lint:fix --since HEAD --exclude-dependents", "lint:examples": "eslint ./examples/**/*.js", "lint:examples:fix": "eslint ./examples/**/*.js --fix", "lint:markdown": "./node_modules/.bin/markdownlint $(git ls-files '*.md') -i ./CHANGELOG.md", @@ -63,7 +65,7 @@ }, "husky": { "hooks": { - "pre-commit": "lerna run --concurrency 1 --stream lint --since HEAD --exclude-dependents", + "pre-commit": "npm run lint:changed", "commit-msg": "commitlint -E HUSKY_GIT_PARAMS" } } diff --git a/packages/opentelemetry-api-metrics/.eslintignore b/packages/opentelemetry-api-metrics/.eslintignore new file mode 100644 index 00000000000..378eac25d31 --- /dev/null +++ b/packages/opentelemetry-api-metrics/.eslintignore @@ -0,0 +1 @@ +build diff --git a/packages/opentelemetry-api-metrics/.eslintrc.js b/packages/opentelemetry-api-metrics/.eslintrc.js new file mode 100644 index 00000000000..e20344660f9 --- /dev/null +++ b/packages/opentelemetry-api-metrics/.eslintrc.js @@ -0,0 +1,8 @@ +module.exports = { + "env": { + "mocha": true, + "commonjs": true, + "shared-node-browser": true + }, + ...require('../../eslint.config.js') +} diff --git a/packages/opentelemetry-api-metrics/LICENSE b/packages/opentelemetry-api-metrics/LICENSE new file mode 100644 index 00000000000..261eeb9e9f8 --- /dev/null +++ b/packages/opentelemetry-api-metrics/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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 + + http://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. diff --git a/packages/opentelemetry-api-metrics/README.md b/packages/opentelemetry-api-metrics/README.md new file mode 100644 index 00000000000..f057571cda3 --- /dev/null +++ b/packages/opentelemetry-api-metrics/README.md @@ -0,0 +1,112 @@ +# OpenTelemetry API for JavaScript + +[![Gitter chat][gitter-image]][gitter-url] +[![NPM Published Version][npm-img]][npm-url] +[![dependencies][dependencies-image]][dependencies-url] +[![devDependencies][devDependencies-image]][devDependencies-url] +[![Apache License][license-image]][license-image] + +This package provides everything needed to interact with the unstable OpenTelemetry Metrics API, including all TypeScript interfaces, enums, and no-op implementations. It is intended for use both on the server and in the browser. + +## Beta Software - Use at your own risk + +The metrics API is considered alpha software and there is no guarantee of stability or long-term support. When the API is stabilized, it will be made available and supported long-term in the `@opentelemetry/api` package and this package will be deprecated. + +## Quick Start + +To get started you need to install the SDK and instrumentations, create a MeterProvider, and register it with the API. + +### Install Dependencies + +```sh +$ # Install metrics dependencies +$ npm install \ + @opentelemetry/api-metrics \ + @opentelemetry/metrics \ + @opentelemetry/exporter-prometheus # add exporters as needed +``` + +> Note: this example is for node.js. See [examples/tracer-web](https://github.com/open-telemetry/opentelemetry-js/tree/master/examples/tracer-web) for a browser example. + +### Initialize the SDK + +Before any other module in your application is loaded, you must initialize the global tracer and meter providers. If you fail to initialize a provider, no-op implementations will be provided to any library which acquires them from the API. + +To collect traces and metrics, you will have to tell the SDK where to export telemetry data to. This example uses Jaeger and Prometheus, but exporters exist for [other tracing backends][other-tracing-backends]. If you're not sure if there is an exporter for your tracing backend, contact your tracing provider. + +#### Metrics + +```javascript +const api = require("@opentelemetry/api-metrics"); +const { MeterProvider } = require("@opentelemetry/metrics"); +const { PrometheusExporter } = require("@opentelemetry/exporter-prometheus"); + +const meterProvider = new MeterProvider({ + // The Prometheus exporter runs an HTTP server which + // the Prometheus backend scrapes to collect metrics. + exporter: new PrometheusExporter({ startServer: true }), + interval: 1000, +}); + +/** + * Registering the provider with the API allows it to be discovered + * and used by instrumentation libraries. + */ +api.metrics.setGlobalMeterProvider(meterProvider); +``` + +## Version Compatibility + +Because the npm installer and node module resolution algorithm could potentially allow two or more copies of any given package to exist within the same `node_modules` structure, the OpenTelemetry API takes advantage of a variable on the `global` object to store the global API. When an API method in the API package is called, it checks if this `global` API exists and proxies calls to it if and only if it is a compatible API version. This means if a package has a dependency on an OpenTelemetry API version which is not compatible with the API used by the end user, the package will receive a no-op implementation of the API. + +## Advanced Use + +### API Methods + +If you are writing an instrumentation library, or prefer to call the API methods directly rather than using the `register` method on the Tracer/Meter Provider, OpenTelemetry provides direct access to the underlying API methods through the `@opentelemetry/api-metrics` package. API entry points are defined as global singleton objects `trace`, `metrics`, `propagation`, and `context` which contain methods used to initialize SDK implementations and acquire resources from the API. + +- [Metrics API Documentation][metrics-api-docs] + +```javascript +const api = require("@opentelemetry/api-metrics"); + +/* Initialize MeterProvider */ +api.metrics.setGlobalMeterProvider(meterProvider); +/* returns meterProvider (no-op if a working provider has not been initialized) */ +api.metrics.getMeterProvider(); +/* returns a meter from the registered global meter provider (no-op if a working provider has not been initialized) */ +api.metrics.getMeter(name, version); +``` + +## Useful links + +- For more information on OpenTelemetry, visit: +- For more about OpenTelemetry JavaScript: +- For help or feedback on this project, join us on [gitter][gitter-url] + +## License + +Apache 2.0 - See [LICENSE][license-url] for more information. + +[gitter-image]: https://badges.gitter.im/open-telemetry/opentelemetry-js.svg +[gitter-url]: https://gitter.im/open-telemetry/opentelemetry-node?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge +[license-url]: https://github.com/open-telemetry/opentelemetry-js/blob/master/LICENSE +[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat +[dependencies-image]: https://david-dm.org/open-telemetry/opentelemetry-js/status.svg?path=packages/opentelemetry-api +[dependencies-url]: https://david-dm.org/open-telemetry/opentelemetry-js?path=packages%2Fopentelemetry-api +[devDependencies-image]: https://david-dm.org/open-telemetry/opentelemetry-js/dev-status.svg?path=packages/opentelemetry-api +[devDependencies-url]: https://david-dm.org/open-telemetry/opentelemetry-js?path=packages%2Fopentelemetry-api&type=dev +[npm-url]: https://www.npmjs.com/package/@opentelemetry/api-metrics +[npm-img]: https://badge.fury.io/js/%40opentelemetry%2Fapi.svg + +[trace-api-docs]: https://open-telemetry.github.io/opentelemetry-js/classes/traceapi.html +[metrics-api-docs]: https://open-telemetry.github.io/opentelemetry-js/classes/metricsapi.html +[propagation-api-docs]: https://open-telemetry.github.io/opentelemetry-js/classes/propagationapi.html +[context-api-docs]: https://open-telemetry.github.io/opentelemetry-js/classes/contextapi.html + +[web]: https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-web +[tracing]: https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-tracing +[node]: https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-node +[metrics]: https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-metrics + +[other-tracing-backends]: https://github.com/open-telemetry/opentelemetry-js#trace-exporters diff --git a/packages/opentelemetry-api-metrics/karma.conf.js b/packages/opentelemetry-api-metrics/karma.conf.js new file mode 100644 index 00000000000..3019564a15b --- /dev/null +++ b/packages/opentelemetry-api-metrics/karma.conf.js @@ -0,0 +1,24 @@ +/*! + * 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 + * + * http://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. + */ + +const karmaWebpackConfig = require('../../karma.webpack'); +const karmaBaseConfig = require('../../karma.base'); + +module.exports = (config) => { + config.set(Object.assign({}, karmaBaseConfig, { + webpack: karmaWebpackConfig + })) +}; diff --git a/packages/opentelemetry-api-metrics/package.json b/packages/opentelemetry-api-metrics/package.json new file mode 100644 index 00000000000..c43e7655d28 --- /dev/null +++ b/packages/opentelemetry-api-metrics/package.json @@ -0,0 +1,73 @@ +{ + "name": "@opentelemetry/api-metrics", + "version": "0.14.0", + "description": "Public metrics API for OpenTelemetry", + "main": "build/src/index.js", + "types": "build/src/index.d.ts", + "browser": { + "./src/platform/index.ts": "./src/platform/browser/index.ts", + "./build/src/platform/index.js": "./build/src/platform/browser/index.js" + }, + "repository": "open-telemetry/opentelemetry-js", + "scripts": { + "compile": "tsc --build", + "clean": "tsc --build --clean", + "test": "nyc ts-mocha -p tsconfig.json test/**/*.test.ts", + "test:browser": "nyc karma start --single-run", + "codecov": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../", + "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../", + "build": "npm run compile", + "lint": "eslint . --ext .ts", + "lint:fix": "eslint . --ext .ts --fix", + "version": "node ../../scripts/version-update.js", + "watch": "tsc --build --watch" + }, + "keywords": [ + "opentelemetry", + "nodejs", + "browser", + "profiling", + "metrics", + "stats", + "monitoring" + ], + "author": "OpenTelemetry Authors", + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + }, + "files": [ + "build/src/**/*.js", + "build/src/**/*.js.map", + "build/src/**/*.d.ts", + "doc", + "LICENSE", + "README.md" + ], + "publishConfig": { + "access": "public" + }, + "dependencies": { + "@opentelemetry/api": "^0.14.0" + }, + "devDependencies": { + "@types/mocha": "8.2.0", + "@types/node": "14.14.12", + "@types/webpack-env": "1.16.0", + "codecov": "3.8.1", + "gts": "2.0.2", + "istanbul-instrumenter-loader": "3.0.1", + "karma": "5.2.3", + "karma-chrome-launcher": "3.1.0", + "karma-coverage-istanbul-reporter": "3.0.3", + "karma-mocha": "2.0.1", + "karma-spec-reporter": "0.0.32", + "karma-webpack": "4.0.2", + "mocha": "7.2.0", + "nyc": "15.1.0", + "ts-loader": "8.0.12", + "ts-mocha": "8.0.0", + "typescript": "3.9.7", + "webpack": "4.44.2" + } +} diff --git a/packages/opentelemetry-api/src/metrics/NoopMeter.ts b/packages/opentelemetry-api-metrics/src/NoopMeter.ts similarity index 93% rename from packages/opentelemetry-api/src/metrics/NoopMeter.ts rename to packages/opentelemetry-api-metrics/src/NoopMeter.ts index 192bf19bec7..45a90b8fd82 100644 --- a/packages/opentelemetry-api/src/metrics/NoopMeter.ts +++ b/packages/opentelemetry-api-metrics/src/NoopMeter.ts @@ -14,8 +14,8 @@ * limitations under the License. */ -import { BatchObserverResult } from './BatchObserverResult'; -import { Meter } from './Meter'; +import { BatchObserverResult } from './types/BatchObserverResult'; +import { Meter } from './types/Meter'; import { MetricOptions, UnboundMetric, @@ -26,15 +26,13 @@ import { UpDownCounter, BaseObserver, UpDownSumObserver, -} from './Metric'; +} from './types/Metric'; import { BoundValueRecorder, BoundCounter, BoundBaseObserver, -} from './BoundInstrument'; -import { Baggage } from '../baggage/Baggage'; -import { SpanContext } from '../trace/span_context'; -import { ObserverResult } from './ObserverResult'; +} from './types/BoundInstrument'; +import { ObserverResult } from './types/ObserverResult'; /** * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses @@ -194,7 +192,7 @@ export class NoopBoundCounter implements BoundCounter { } export class NoopBoundValueRecorder implements BoundValueRecorder { - record(_value: number, _baggage?: Baggage, _spanContext?: SpanContext): void { + record(_value: number, _baggage?: unknown, _spanContext?: unknown): void { return; } } diff --git a/packages/opentelemetry-api/src/metrics/NoopMeterProvider.ts b/packages/opentelemetry-api-metrics/src/NoopMeterProvider.ts similarity index 91% rename from packages/opentelemetry-api/src/metrics/NoopMeterProvider.ts rename to packages/opentelemetry-api-metrics/src/NoopMeterProvider.ts index 13e73c0e2fd..2cc737960e6 100644 --- a/packages/opentelemetry-api/src/metrics/NoopMeterProvider.ts +++ b/packages/opentelemetry-api-metrics/src/NoopMeterProvider.ts @@ -14,8 +14,8 @@ * limitations under the License. */ -import { Meter } from './Meter'; -import { MeterProvider } from './MeterProvider'; +import { Meter } from './types/Meter'; +import { MeterProvider } from './types/MeterProvider'; import { NOOP_METER } from './NoopMeter'; /** diff --git a/packages/opentelemetry-api-metrics/src/api/global-utils.ts b/packages/opentelemetry-api-metrics/src/api/global-utils.ts new file mode 100644 index 00000000000..a23f76396d7 --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/api/global-utils.ts @@ -0,0 +1,55 @@ +/* + * 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 { MeterProvider } from '../types/MeterProvider'; +import { _globalThis } from '../platform'; + +export const GLOBAL_METRICS_API_KEY = Symbol.for( + 'io.opentelemetry.js.api.metrics' +); + +type Get = (version: number) => T; +type OtelGlobal = Partial<{ + [GLOBAL_METRICS_API_KEY]: Get; +}>; + +export const _global = _globalThis as OtelGlobal; + +/** + * Make a function which accepts a version integer and returns the instance of an API if the version + * is compatible, or a fallback version (usually NOOP) if it is not. + * + * @param requiredVersion Backwards compatibility version which is required to return the instance + * @param instance Instance which should be returned if the required version is compatible + * @param fallback Fallback instance, usually NOOP, which will be returned if the required version is not compatible + */ +export function makeGetter( + requiredVersion: number, + instance: T, + fallback: T +): Get { + return (version: number): T => + version === requiredVersion ? instance : fallback; +} + +/** + * A number which should be incremented each time a backwards incompatible + * change is made to the API. This number is used when an API package + * attempts to access the global API to ensure it is getting a compatible + * version. If the global API is not compatible with the API package + * attempting to get it, a NOOP API implementation will be returned. + */ +export const API_BACKWARDS_COMPATIBILITY_VERSION = 3; diff --git a/packages/opentelemetry-api/src/api/metrics.ts b/packages/opentelemetry-api-metrics/src/api/metrics.ts similarity index 93% rename from packages/opentelemetry-api/src/api/metrics.ts rename to packages/opentelemetry-api-metrics/src/api/metrics.ts index f06b09fa367..1ff07acc06a 100644 --- a/packages/opentelemetry-api/src/api/metrics.ts +++ b/packages/opentelemetry-api-metrics/src/api/metrics.ts @@ -14,9 +14,9 @@ * limitations under the License. */ -import { Meter } from '../metrics/Meter'; -import { MeterProvider } from '../metrics/MeterProvider'; -import { NOOP_METER_PROVIDER } from '../metrics/NoopMeterProvider'; +import { Meter } from '../types/Meter'; +import { MeterProvider } from '../types/MeterProvider'; +import { NOOP_METER_PROVIDER } from '../NoopMeterProvider'; import { API_BACKWARDS_COMPATIBILITY_VERSION, GLOBAL_METRICS_API_KEY, diff --git a/packages/opentelemetry-api-metrics/src/index.ts b/packages/opentelemetry-api-metrics/src/index.ts new file mode 100644 index 00000000000..de39eb08215 --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/index.ts @@ -0,0 +1,29 @@ +/* + * 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 * from './NoopMeter'; +export * from './NoopMeterProvider'; +export * from './types/BatchObserverResult'; +export * from './types/BoundInstrument'; +export * from './types/Meter'; +export * from './types/MeterProvider'; +export * from './types/Metric'; +export * from './types/Observation'; +export * from './types/ObserverResult'; + +import { MetricsAPI } from './api/metrics'; +/** Entrypoint for metrics API */ +export const metrics = MetricsAPI.getInstance(); diff --git a/packages/opentelemetry-api-metrics/src/platform/browser/globalThis.ts b/packages/opentelemetry-api-metrics/src/platform/browser/globalThis.ts new file mode 100644 index 00000000000..34a8254b888 --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/platform/browser/globalThis.ts @@ -0,0 +1,19 @@ +/* + * 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. + */ + +/** only globals that common to node and browsers are allowed */ +// eslint-disable-next-line node/no-unsupported-features/es-builtins, no-undef +export const _globalThis = typeof globalThis === 'object' ? globalThis : window; diff --git a/packages/opentelemetry-api-metrics/src/platform/browser/index.ts b/packages/opentelemetry-api-metrics/src/platform/browser/index.ts new file mode 100644 index 00000000000..e9d6ebed71c --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/platform/browser/index.ts @@ -0,0 +1,17 @@ +/* + * 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 * from './globalThis'; diff --git a/packages/opentelemetry-api-metrics/src/platform/index.ts b/packages/opentelemetry-api-metrics/src/platform/index.ts new file mode 100644 index 00000000000..cdaf8858ce5 --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/platform/index.ts @@ -0,0 +1,17 @@ +/* + * 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 * from './node'; diff --git a/packages/opentelemetry-api-metrics/src/platform/node/globalThis.ts b/packages/opentelemetry-api-metrics/src/platform/node/globalThis.ts new file mode 100644 index 00000000000..36e97e27326 --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/platform/node/globalThis.ts @@ -0,0 +1,19 @@ +/* + * 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. + */ + +/** only globals that common to node and browsers are allowed */ +// eslint-disable-next-line node/no-unsupported-features/es-builtins +export const _globalThis = typeof globalThis === 'object' ? globalThis : global; diff --git a/packages/opentelemetry-api-metrics/src/platform/node/index.ts b/packages/opentelemetry-api-metrics/src/platform/node/index.ts new file mode 100644 index 00000000000..e9d6ebed71c --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/platform/node/index.ts @@ -0,0 +1,17 @@ +/* + * 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 * from './globalThis'; diff --git a/packages/opentelemetry-api/src/metrics/BatchObserverResult.ts b/packages/opentelemetry-api-metrics/src/types/BatchObserverResult.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/BatchObserverResult.ts rename to packages/opentelemetry-api-metrics/src/types/BatchObserverResult.ts diff --git a/packages/opentelemetry-api/src/metrics/BoundInstrument.ts b/packages/opentelemetry-api-metrics/src/types/BoundInstrument.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/BoundInstrument.ts rename to packages/opentelemetry-api-metrics/src/types/BoundInstrument.ts diff --git a/packages/opentelemetry-api/src/metrics/Meter.ts b/packages/opentelemetry-api-metrics/src/types/Meter.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/Meter.ts rename to packages/opentelemetry-api-metrics/src/types/Meter.ts diff --git a/packages/opentelemetry-api/src/metrics/MeterProvider.ts b/packages/opentelemetry-api-metrics/src/types/MeterProvider.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/MeterProvider.ts rename to packages/opentelemetry-api-metrics/src/types/MeterProvider.ts diff --git a/packages/opentelemetry-api/src/metrics/Metric.ts b/packages/opentelemetry-api-metrics/src/types/Metric.ts similarity index 99% rename from packages/opentelemetry-api/src/metrics/Metric.ts rename to packages/opentelemetry-api-metrics/src/types/Metric.ts index 75e7a78d397..a6741813896 100644 --- a/packages/opentelemetry-api/src/metrics/Metric.ts +++ b/packages/opentelemetry-api-metrics/src/types/Metric.ts @@ -19,7 +19,7 @@ import { BoundCounter, BoundValueRecorder, } from './BoundInstrument'; -import { Logger } from '../common/Logger'; +import { Logger } from '@opentelemetry/api'; /** * Options needed for metric creation diff --git a/packages/opentelemetry-api/src/metrics/Observation.ts b/packages/opentelemetry-api-metrics/src/types/Observation.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/Observation.ts rename to packages/opentelemetry-api-metrics/src/types/Observation.ts diff --git a/packages/opentelemetry-api/src/metrics/ObserverResult.ts b/packages/opentelemetry-api-metrics/src/types/ObserverResult.ts similarity index 100% rename from packages/opentelemetry-api/src/metrics/ObserverResult.ts rename to packages/opentelemetry-api-metrics/src/types/ObserverResult.ts diff --git a/packages/opentelemetry-api-metrics/src/version.ts b/packages/opentelemetry-api-metrics/src/version.ts new file mode 100644 index 00000000000..bc552fd543c --- /dev/null +++ b/packages/opentelemetry-api-metrics/src/version.ts @@ -0,0 +1,18 @@ +/* + * 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. + */ + +// this is autogenerated file, see scripts/version-update.js +export const VERSION = '0.14.0'; diff --git a/packages/opentelemetry-api-metrics/test/api/api.test.ts b/packages/opentelemetry-api-metrics/test/api/api.test.ts new file mode 100644 index 00000000000..674e9aebd49 --- /dev/null +++ b/packages/opentelemetry-api-metrics/test/api/api.test.ts @@ -0,0 +1,46 @@ +/* + * 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 * as assert from 'assert'; +import { metrics, NoopMeter, NoopMeterProvider } from '../../src'; + +describe('API', () => { + it('should expose a meter provider via getMeterProvider', () => { + const meter = metrics.getMeterProvider(); + assert.ok(meter); + assert.strictEqual(typeof meter, 'object'); + }); + + describe('GlobalMeterProvider', () => { + const dummyMeter = new NoopMeter(); + + beforeEach(() => { + metrics.disable(); + }); + + it('should use the global meter provider', () => { + metrics.setGlobalMeterProvider(new TestMeterProvider()); + const meter = metrics.getMeterProvider().getMeter('name'); + assert.deepStrictEqual(meter, dummyMeter); + }); + + class TestMeterProvider extends NoopMeterProvider { + getMeter() { + return dummyMeter; + } + } + }); +}); diff --git a/packages/opentelemetry-api-metrics/test/api/global.test.ts b/packages/opentelemetry-api-metrics/test/api/global.test.ts new file mode 100644 index 00000000000..485c68c41a4 --- /dev/null +++ b/packages/opentelemetry-api-metrics/test/api/global.test.ts @@ -0,0 +1,76 @@ +/* + * 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 * as assert from 'assert'; +import { _global, GLOBAL_METRICS_API_KEY } from '../../src/api/global-utils'; +import { NoopMeterProvider } from '../../src'; + +const api1 = require('../../src') as typeof import('../../src'); + +// clear cache and load a second instance of the api +for (const key of Object.keys(require.cache)) { + delete require.cache[key]; +} +const api2 = require('../../src') as typeof import('../../src'); + +describe('Global Utils', () => { + // prove they are separate instances + assert.notStrictEqual(api1, api2); + // that return separate noop instances to start + assert.notStrictEqual( + api1.metrics.getMeterProvider(), + api2.metrics.getMeterProvider() + ); + + beforeEach(() => { + api1.metrics.disable(); + api2.metrics.disable(); + }); + + it('should change the global meter provider', () => { + const original = api1.metrics.getMeterProvider(); + const newMeterProvider = new NoopMeterProvider(); + api1.metrics.setGlobalMeterProvider(newMeterProvider); + assert.notStrictEqual(api1.metrics.getMeterProvider(), original); + assert.strictEqual(api1.metrics.getMeterProvider(), newMeterProvider); + }); + + it('should load an instance from one which was set in the other', () => { + api1.metrics.setGlobalMeterProvider(new NoopMeterProvider()); + assert.strictEqual( + api1.metrics.getMeterProvider(), + api2.metrics.getMeterProvider() + ); + }); + + it('should disable both if one is disabled', () => { + const original = api1.metrics.getMeterProvider(); + + api1.metrics.setGlobalMeterProvider(new NoopMeterProvider()); + + assert.notStrictEqual(original, api1.metrics.getMeterProvider()); + api2.metrics.disable(); + assert.strictEqual(original, api1.metrics.getMeterProvider()); + }); + + it('should return the module NoOp implementation if the version is a mismatch', () => { + const original = api1.metrics.getMeterProvider(); + api1.metrics.setGlobalMeterProvider(new NoopMeterProvider()); + const afterSet = _global[GLOBAL_METRICS_API_KEY]!(-1); + + assert.strictEqual(original, afterSet); + }); +}); diff --git a/packages/opentelemetry-api-metrics/test/index-webpack.ts b/packages/opentelemetry-api-metrics/test/index-webpack.ts new file mode 100644 index 00000000000..061a48ccfa7 --- /dev/null +++ b/packages/opentelemetry-api-metrics/test/index-webpack.ts @@ -0,0 +1,20 @@ +/* + * 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. + */ +const testsContext = require.context('.', true, /test$/); +testsContext.keys().forEach(testsContext); + +const srcContext = require.context('.', true, /src$/); +srcContext.keys().forEach(srcContext); diff --git a/packages/opentelemetry-api/test/noop-implementations/noop-meter.test.ts b/packages/opentelemetry-api-metrics/test/noop-implementations/noop-meter.test.ts similarity index 100% rename from packages/opentelemetry-api/test/noop-implementations/noop-meter.test.ts rename to packages/opentelemetry-api-metrics/test/noop-implementations/noop-meter.test.ts diff --git a/packages/opentelemetry-api-metrics/tsconfig.docs.json b/packages/opentelemetry-api-metrics/tsconfig.docs.json new file mode 100644 index 00000000000..627fa3ff3e5 --- /dev/null +++ b/packages/opentelemetry-api-metrics/tsconfig.docs.json @@ -0,0 +1,15 @@ +{ + "compilerOptions": { + "rootDir": ".", + "outDir": "build" + }, + "include": [ + "src/**/*.ts" + ], + "typedocOptions": { + "name": "OpenTelemetry API for JavaScript", + "out": "docs/out", + "mode": "file", + "hideGenerator": true + } +} diff --git a/packages/opentelemetry-api-metrics/tsconfig.json b/packages/opentelemetry-api-metrics/tsconfig.json new file mode 100644 index 00000000000..f0d9f58500a --- /dev/null +++ b/packages/opentelemetry-api-metrics/tsconfig.json @@ -0,0 +1,16 @@ +{ + "extends": "../../tsconfig.es5.json", + "compilerOptions": { + "rootDir": ".", + "outDir": "build" + }, + "include": [ + "src/**/*.ts", + "test/**/*.ts" + ], + "references": [ + { + "path": "../opentelemetry-api" + } + ] +} diff --git a/packages/opentelemetry-api/README.md b/packages/opentelemetry-api/README.md index 0f91bb0bca1..c5f02e37f6f 100644 --- a/packages/opentelemetry-api/README.md +++ b/packages/opentelemetry-api/README.md @@ -10,7 +10,7 @@ This package provides everything needed to interact with the OpenTelemetry API, ## Quick Start -To get started you need to install the SDK and plugins, create a TracerProvider and/or MeterProvider, and register it with the API. +To get started you need to install the SDK and plugins, create a TracerProvider, and register it with the API. ### Install Dependencies @@ -23,11 +23,6 @@ $ npm install \ @opentelemetry/tracing \ @opentelemetry/exporter-jaeger \ # add exporters as needed @opentelemetry/plugin-http # add plugins as needed - -$ # Install metrics dependencies -$ npm install \ - @opentelemetry/metrics \ - @opentelemetry/exporter-prometheus # add exporters as needed ``` > Note: this example is for node.js. See [examples/tracer-web](https://github.com/open-telemetry/opentelemetry-js/tree/master/examples/tracer-web) for a browser example. @@ -74,27 +69,6 @@ tracerProvider.addSpanProcessor( tracerProvider.register(); ``` -#### Metrics - -```javascript -const api = require("@opentelemetry/api"); -const { MeterProvider } = require("@opentelemetry/metrics"); -const { PrometheusExporter } = require("@opentelemetry/exporter-prometheus"); - -const meterProvider = new MeterProvider({ - // The Prometheus exporter runs an HTTP server which - // the Prometheus backend scrapes to collect metrics. - exporter: new PrometheusExporter({ startServer: true }), - interval: 1000, -}); - -/** - * Registering the provider with the API allows it to be discovered - * and used by instrumentation libraries. - */ -api.metrics.setGlobalMeterProvider(meterProvider); -``` - ## Version Compatibility Because the npm installer and node module resolution algorithm could potentially allow two or more copies of any given package to exist within the same `node_modules` structure, the OpenTelemetry API takes advantage of a variable on the `global` object to store the global API. When an API method in the API package is called, it checks if this `global` API exists and proxies calls to it if and only if it is a compatible API version. This means if a package has a dependency on an OpenTelemetry API version which is not compatible with the API used by the end user, the package will receive a no-op implementation of the API. @@ -122,7 +96,6 @@ tracerProvider.register({ If you are writing an instrumentation library, or prefer to call the API methods directly rather than using the `register` method on the Tracer/Meter Provider, OpenTelemetry provides direct access to the underlying API methods through the `@opentelemetry/api` package. API entry points are defined as global singleton objects `trace`, `metrics`, `propagation`, and `context` which contain methods used to initialize SDK implementations and acquire resources from the API. - [Trace API Documentation][trace-api-docs] -- [Metrics API Documentation][metrics-api-docs] - [Propagation API Documentation][propagation-api-docs] - [Context API Documentation][context-api-docs] @@ -136,13 +109,6 @@ api.trace.getTracerProvider(); /* returns a tracer from the registered global tracer provider (no-op if a working provider has not been initialized) */ api.trace.getTracer(name, version); -/* Initialize MeterProvider */ -api.metrics.setGlobalMeterProvider(meterProvider); -/* returns meterProvider (no-op if a working provider has not been initialized) */ -api.metrics.getMeterProvider(); -/* returns a meter from the registered global meter provider (no-op if a working provider has not been initialized) */ -api.metrics.getMeter(name, version); - /* Initialize Propagator */ api.propagation.setGlobalPropagator(httpTraceContextPropagator); diff --git a/packages/opentelemetry-api/package.json b/packages/opentelemetry-api/package.json index 66159e9049b..eb0fc0db377 100644 --- a/packages/opentelemetry-api/package.json +++ b/packages/opentelemetry-api/package.json @@ -30,7 +30,6 @@ "browser", "tracing", "profiling", - "metrics", "stats", "monitoring" ], diff --git a/packages/opentelemetry-api/src/api/global-utils.ts b/packages/opentelemetry-api/src/api/global-utils.ts index 5d6ad7de3e0..0ab9d663e5d 100644 --- a/packages/opentelemetry-api/src/api/global-utils.ts +++ b/packages/opentelemetry-api/src/api/global-utils.ts @@ -16,16 +16,13 @@ import { ContextManager } from '@opentelemetry/context-base'; import { TextMapPropagator } from '../context/propagation/TextMapPropagator'; -import { MeterProvider } from '../metrics/MeterProvider'; import { TracerProvider } from '../trace/tracer_provider'; import { _globalThis } from '../platform'; export const GLOBAL_CONTEXT_MANAGER_API_KEY = Symbol.for( 'io.opentelemetry.js.api.context' ); -export const GLOBAL_METRICS_API_KEY = Symbol.for( - 'io.opentelemetry.js.api.metrics' -); + export const GLOBAL_PROPAGATION_API_KEY = Symbol.for( 'io.opentelemetry.js.api.propagation' ); @@ -34,7 +31,6 @@ export const GLOBAL_TRACE_API_KEY = Symbol.for('io.opentelemetry.js.api.trace'); type Get = (version: number) => T; type OtelGlobal = Partial<{ [GLOBAL_CONTEXT_MANAGER_API_KEY]: Get; - [GLOBAL_METRICS_API_KEY]: Get; [GLOBAL_PROPAGATION_API_KEY]: Get; [GLOBAL_TRACE_API_KEY]: Get; }>; diff --git a/packages/opentelemetry-api/src/index.ts b/packages/opentelemetry-api/src/index.ts index c19be4333a8..7c5bbd76f56 100644 --- a/packages/opentelemetry-api/src/index.ts +++ b/packages/opentelemetry-api/src/index.ts @@ -22,15 +22,6 @@ export * from './context/propagation/TextMapPropagator'; export * from './context/propagation/NoopTextMapPropagator'; export * from './baggage/Baggage'; export * from './baggage/EntryValue'; -export * from './metrics/BatchObserverResult'; -export * from './metrics/BoundInstrument'; -export * from './metrics/Meter'; -export * from './metrics/MeterProvider'; -export * from './metrics/Metric'; -export * from './metrics/NoopMeter'; -export * from './metrics/NoopMeterProvider'; -export * from './metrics/Observation'; -export * from './metrics/ObserverResult'; export * from './trace/attributes'; export * from './trace/Event'; export * from './trace/link_context'; @@ -78,17 +69,12 @@ import { TraceAPI } from './api/trace'; /** Entrypoint for trace API */ export const trace = TraceAPI.getInstance(); -import { MetricsAPI } from './api/metrics'; -/** Entrypoint for metrics API */ -export const metrics = MetricsAPI.getInstance(); - import { PropagationAPI } from './api/propagation'; /** Entrypoint for propagation API */ export const propagation = PropagationAPI.getInstance(); export default { trace, - metrics, context, propagation, }; diff --git a/packages/opentelemetry-api/test/api/api.test.ts b/packages/opentelemetry-api/test/api/api.test.ts index cc02a460f8f..bb15fb02e9b 100644 --- a/packages/opentelemetry-api/test/api/api.test.ts +++ b/packages/opentelemetry-api/test/api/api.test.ts @@ -25,7 +25,6 @@ import api, { context, trace, propagation, - metrics, TextMapPropagator, Context, TextMapSetter, @@ -54,7 +53,6 @@ describe('API', () => { context.disable(); trace.disable(); propagation.disable(); - metrics.disable(); }); it('should use the global tracer provider', () => { diff --git a/packages/opentelemetry-api/test/api/global.test.ts b/packages/opentelemetry-api/test/api/global.test.ts index 7d9ea5b9caa..5a489650715 100644 --- a/packages/opentelemetry-api/test/api/global.test.ts +++ b/packages/opentelemetry-api/test/api/global.test.ts @@ -42,7 +42,6 @@ describe('Global Utils', () => { api1.context.disable(); api1.propagation.disable(); api1.trace.disable(); - api1.metrics.disable(); }); it('should change the global context manager', () => { diff --git a/packages/opentelemetry-exporter-collector-grpc/package.json b/packages/opentelemetry-exporter-collector-grpc/package.json index 4a408eb2e37..2a2102c5183 100644 --- a/packages/opentelemetry-exporter-collector-grpc/package.json +++ b/packages/opentelemetry-exporter-collector-grpc/package.json @@ -46,6 +46,7 @@ }, "devDependencies": { "@babel/core": "7.12.10", + "@opentelemetry/api-metrics": "^0.14.0", "@types/mocha": "8.2.0", "@types/node": "14.14.20", "@types/sinon": "9.0.10", diff --git a/packages/opentelemetry-exporter-collector-grpc/test/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector-grpc/test/CollectorMetricExporter.test.ts index ca2e8767a79..228cf8c818f 100644 --- a/packages/opentelemetry-exporter-collector-grpc/test/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector-grpc/test/CollectorMetricExporter.test.ts @@ -15,27 +15,30 @@ */ import * as protoLoader from '@grpc/proto-loader'; +import { + Counter, + ValueObserver, + ValueRecorder, +} from '@opentelemetry/api-metrics'; +import { ConsoleLogger, LogLevel } from '@opentelemetry/core'; +import { collectorTypes } from '@opentelemetry/exporter-collector'; +import * as metrics from '@opentelemetry/metrics'; +import * as assert from 'assert'; +import * as fs from 'fs'; import * as grpc from 'grpc'; import * as path from 'path'; -import * as fs from 'fs'; - -import * as assert from 'assert'; import * as sinon from 'sinon'; -import { collectorTypes } from '@opentelemetry/exporter-collector'; import { CollectorMetricExporter } from '../src'; import { - mockCounter, - mockObserver, ensureExportedCounterIsCorrect, ensureExportedObserverIsCorrect, + ensureExportedValueRecorderIsCorrect, ensureMetadataIsCorrect, ensureResourceIsCorrect, - ensureExportedValueRecorderIsCorrect, + mockCounter, + mockObserver, mockValueRecorder, } from './helper'; -import { ConsoleLogger, LogLevel } from '@opentelemetry/core'; -import * as api from '@opentelemetry/api'; -import * as metrics from '@opentelemetry/metrics'; const metricsServiceProtoPath = 'opentelemetry/proto/collector/metrics/v1/metrics_service.proto'; @@ -136,14 +139,14 @@ const testCollectorMetricExporter = (params: TestParams) => }); metrics = []; const counter: metrics.Metric & - api.Counter = mockCounter(); + Counter = mockCounter(); const observer: metrics.Metric & - api.ValueObserver = mockObserver(observerResult => { + ValueObserver = mockObserver(observerResult => { observerResult.observe(3, {}); observerResult.observe(6, {}); }); const recorder: metrics.Metric & - api.ValueRecorder = mockValueRecorder(); + ValueRecorder = mockValueRecorder(); counter.add(1); recorder.record(7); diff --git a/packages/opentelemetry-exporter-collector-grpc/test/helper.ts b/packages/opentelemetry-exporter-collector-grpc/test/helper.ts index a425e5de931..472120ba9ed 100644 --- a/packages/opentelemetry-exporter-collector-grpc/test/helper.ts +++ b/packages/opentelemetry-exporter-collector-grpc/test/helper.ts @@ -14,11 +14,18 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { StatusCode, TraceFlags } from '@opentelemetry/api'; +import { + Counter, + ObserverResult, + ValueObserver, + ValueRecorder, + ValueType, +} from '@opentelemetry/api-metrics'; +import { collectorTypes } from '@opentelemetry/exporter-collector'; import * as metrics from '@opentelemetry/metrics'; -import { ReadableSpan } from '@opentelemetry/tracing'; import { Resource } from '@opentelemetry/resources'; -import { collectorTypes } from '@opentelemetry/exporter-collector'; +import { ReadableSpan } from '@opentelemetry/tracing'; import * as assert from 'assert'; import * as grpc from 'grpc'; @@ -54,14 +61,13 @@ const traceIdArr = [ const spanIdArr = [94, 16, 114, 97, 246, 79, 165, 62]; const parentIdArr = [120, 168, 145, 80, 152, 134, 67, 136]; -export function mockCounter(): metrics.Metric & - api.Counter { +export function mockCounter(): metrics.Metric & Counter { const name = 'int-counter'; const metric = meter['_metrics'].get(name) || meter.createCounter(name, { description: 'sample counter description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, }); metric.clear(); metric.bind({}); @@ -69,8 +75,8 @@ export function mockCounter(): metrics.Metric & } export function mockObserver( - callback: (observerResult: api.ObserverResult) => void -): metrics.Metric & api.ValueObserver { + callback: (observerResult: ObserverResult) => void +): metrics.Metric & ValueObserver { const name = 'double-observer'; const metric = meter['_metrics'].get(name) || @@ -78,7 +84,7 @@ export function mockObserver( name, { description: 'sample observer description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }, callback ); @@ -88,13 +94,13 @@ export function mockObserver( } export function mockValueRecorder(): metrics.Metric & - api.ValueRecorder { + ValueRecorder { const name = 'int-recorder'; const metric = meter['_metrics'].get(name) || meter.createValueRecorder(name, { description: 'sample recorder description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, boundaries: [0, 100], }); metric.clear(); @@ -108,13 +114,13 @@ export const mockedReadableSpan: ReadableSpan = { spanContext: { traceId: '1f1008dc8e270e85c40a0d7c3939b278', spanId: '5e107261f64fa53e', - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: '78a8915098864388', startTime: [1574120165, 429803070], endTime: [1574120165, 438688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: { component: 'document-load' }, links: [ { diff --git a/packages/opentelemetry-exporter-collector-grpc/tsconfig.json b/packages/opentelemetry-exporter-collector-grpc/tsconfig.json index bfdc997b940..1e107c066b5 100644 --- a/packages/opentelemetry-exporter-collector-grpc/tsconfig.json +++ b/packages/opentelemetry-exporter-collector-grpc/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-core" }, diff --git a/packages/opentelemetry-exporter-collector-proto/package.json b/packages/opentelemetry-exporter-collector-proto/package.json index 91e4a97dea2..9566624da39 100644 --- a/packages/opentelemetry-exporter-collector-proto/package.json +++ b/packages/opentelemetry-exporter-collector-proto/package.json @@ -46,6 +46,7 @@ }, "devDependencies": { "@babel/core": "7.12.10", + "@opentelemetry/api-metrics": "^0.14.0", "@types/mocha": "8.2.0", "@types/node": "14.14.20", "@types/sinon": "9.0.10", diff --git a/packages/opentelemetry-exporter-collector-proto/test/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector-proto/test/CollectorMetricExporter.test.ts index fb912a26a98..aa83283011d 100644 --- a/packages/opentelemetry-exporter-collector-proto/test/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector-proto/test/CollectorMetricExporter.test.ts @@ -14,7 +14,12 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { NoopLogger } from '@opentelemetry/api'; +import { + Counter, + ValueObserver, + ValueRecorder, +} from '@opentelemetry/api-metrics'; import { ExportResultCode } from '@opentelemetry/core'; import { CollectorExporterNodeConfigBase, @@ -55,7 +60,7 @@ describe('CollectorMetricExporter - node with proto over http', () => { foo: 'bar', }, hostname: 'foo', - logger: new api.NoopLogger(), + logger: new NoopLogger(), serviceName: 'bar', attributes: {}, url: 'http://foo.bar.com', @@ -69,14 +74,14 @@ describe('CollectorMetricExporter - node with proto over http', () => { }); metrics = []; const counter: metrics.Metric & - api.Counter = mockCounter(); + Counter = mockCounter(); const observer: metrics.Metric & - api.ValueObserver = mockObserver(observerResult => { + ValueObserver = mockObserver(observerResult => { observerResult.observe(3, {}); observerResult.observe(6, {}); }); const recorder: metrics.Metric & - api.ValueRecorder = mockValueRecorder(); + ValueRecorder = mockValueRecorder(); counter.add(1); recorder.record(7); diff --git a/packages/opentelemetry-exporter-collector-proto/test/helper.ts b/packages/opentelemetry-exporter-collector-proto/test/helper.ts index a2edcfd9f4c..abb4af5e7ee 100644 --- a/packages/opentelemetry-exporter-collector-proto/test/helper.ts +++ b/packages/opentelemetry-exporter-collector-proto/test/helper.ts @@ -14,12 +14,19 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; -import * as metrics from '@opentelemetry/metrics'; +import { StatusCode, TraceFlags } from '@opentelemetry/api'; +import { + Counter, + ObserverResult, + ValueObserver, + ValueRecorder, + ValueType, +} from '@opentelemetry/api-metrics'; import { hexToBase64 } from '@opentelemetry/core'; -import { ReadableSpan } from '@opentelemetry/tracing'; -import { Resource } from '@opentelemetry/resources'; import { collectorTypes } from '@opentelemetry/exporter-collector'; +import * as metrics from '@opentelemetry/metrics'; +import { Resource } from '@opentelemetry/resources'; +import { ReadableSpan } from '@opentelemetry/tracing'; import * as assert from 'assert'; import { Stream } from 'stream'; @@ -34,14 +41,13 @@ const meterProvider = new metrics.MeterProvider({ const meter = meterProvider.getMeter('default', '0.0.1'); -export function mockCounter(): metrics.Metric & - api.Counter { +export function mockCounter(): metrics.Metric & Counter { const name = 'int-counter'; const metric = meter['_metrics'].get(name) || meter.createCounter(name, { description: 'sample counter description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, }); metric.clear(); metric.bind({}); @@ -49,8 +55,8 @@ export function mockCounter(): metrics.Metric & } export function mockObserver( - callback: (observerResult: api.ObserverResult) => void -): metrics.Metric & api.ValueObserver { + callback: (observerResult: ObserverResult) => void +): metrics.Metric & ValueObserver { const name = 'double-observer'; const metric = meter['_metrics'].get(name) || @@ -58,7 +64,7 @@ export function mockObserver( name, { description: 'sample observer description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }, callback ); @@ -68,13 +74,13 @@ export function mockObserver( } export function mockValueRecorder(): metrics.Metric & - api.ValueRecorder { + ValueRecorder { const name = 'int-recorder'; const metric = meter['_metrics'].get(name) || meter.createValueRecorder(name, { description: 'sample recorder description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, boundaries: [0, 100], }); metric.clear(); @@ -92,13 +98,13 @@ export const mockedReadableSpan: ReadableSpan = { spanContext: { traceId: traceIdHex, spanId: spanIdHex, - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: parentIdHex, startTime: [1574120165, 429803070], endTime: [1574120165, 438688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: { component: 'document-load' }, links: [ { diff --git a/packages/opentelemetry-exporter-collector-proto/tsconfig.json b/packages/opentelemetry-exporter-collector-proto/tsconfig.json index bfdc997b940..1e107c066b5 100644 --- a/packages/opentelemetry-exporter-collector-proto/tsconfig.json +++ b/packages/opentelemetry-exporter-collector-proto/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-core" }, diff --git a/packages/opentelemetry-exporter-collector/package.json b/packages/opentelemetry-exporter-collector/package.json index e8f858b3e9e..d4acb9d0a39 100644 --- a/packages/opentelemetry-exporter-collector/package.json +++ b/packages/opentelemetry-exporter-collector/package.json @@ -78,6 +78,7 @@ }, "dependencies": { "@opentelemetry/api": "^0.14.0", + "@opentelemetry/api-metrics": "^0.14.0", "@opentelemetry/core": "^0.14.0", "@opentelemetry/metrics": "^0.14.0", "@opentelemetry/resources": "^0.14.0", diff --git a/packages/opentelemetry-exporter-collector/src/transformMetrics.ts b/packages/opentelemetry-exporter-collector/src/transformMetrics.ts index 1128a232607..6240de5c494 100644 --- a/packages/opentelemetry-exporter-collector/src/transformMetrics.ts +++ b/packages/opentelemetry-exporter-collector/src/transformMetrics.ts @@ -14,26 +14,26 @@ * limitations under the License. */ +import { Attributes, HrTime } from '@opentelemetry/api'; +import { Labels, ValueType } from '@opentelemetry/api-metrics'; +import * as core from '@opentelemetry/core'; import { - MetricRecord, - MetricKind, - Histogram, AggregatorKind, + Histogram, + MetricKind, + MetricRecord, } from '@opentelemetry/metrics'; -import { opentelemetryProto, CollectorExporterConfigBase } from './types'; -import * as api from '@opentelemetry/api'; -import * as core from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; -import { toCollectorResource } from './transform'; import { CollectorExporterBase } from './CollectorExporterBase'; -import { HrTime } from '@opentelemetry/api'; +import { toCollectorResource } from './transform'; +import { CollectorExporterConfigBase, opentelemetryProto } from './types'; /** * Converts labels * @param labels */ export function toCollectorLabels( - labels: api.Labels + labels: Labels ): opentelemetryProto.common.v1.StringKeyValue[] { return Object.entries(labels).map(([key, value]) => { return { key, value: String(value) }; @@ -148,7 +148,7 @@ export function toCollectorMetric( metric.descriptor.metricKind === MetricKind.SUM_OBSERVER, aggregationTemporality: toAggregationTemporality(metric), }; - if (metric.descriptor.valueType === api.ValueType.INT) { + if (metric.descriptor.valueType === ValueType.INT) { metricCollector.intSum = result; } else { metricCollector.doubleSum = result; @@ -157,7 +157,7 @@ export function toCollectorMetric( const result = { dataPoints: [toDataPoint(metric, startTime)], }; - if (metric.descriptor.valueType === api.ValueType.INT) { + if (metric.descriptor.valueType === ValueType.INT) { metricCollector.intGauge = result; } else { metricCollector.doubleGauge = result; @@ -167,7 +167,7 @@ export function toCollectorMetric( dataPoints: [toHistogramPoint(metric, startTime)], aggregationTemporality: toAggregationTemporality(metric), }; - if (metric.descriptor.valueType === api.ValueType.INT) { + if (metric.descriptor.valueType === ValueType.INT) { metricCollector.intHistogram = result; } else { metricCollector.doubleHistogram = result; @@ -267,7 +267,7 @@ function toCollectorResourceMetrics( Resource, Map >, - baseAttributes: api.Attributes, + baseAttributes: Attributes, startTime: number ): opentelemetryProto.metrics.v1.ResourceMetrics[] { return Array.from(groupedMetrics, ([resource, libMetrics]) => { diff --git a/packages/opentelemetry-exporter-collector/test/browser/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector/test/browser/CollectorMetricExporter.test.ts index 9a8d39491d6..03e89e93c9b 100644 --- a/packages/opentelemetry-exporter-collector/test/browser/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/browser/CollectorMetricExporter.test.ts @@ -14,13 +14,13 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; -import { ExportResultCode } from '@opentelemetry/core'; -import * as assert from 'assert'; -import * as sinon from 'sinon'; -import { CollectorMetricExporter } from '../../src/platform/browser/index'; -import { CollectorExporterConfigBase } from '../../src/types'; -import * as collectorTypes from '../../src/types'; +import { NoopLogger } from '@opentelemetry/api'; +import { + Counter, + ValueObserver, + ValueRecorder, +} from '@opentelemetry/api-metrics'; +import { ExportResultCode, hrTimeToNanoseconds } from '@opentelemetry/core'; import { BoundCounter, BoundObserver, @@ -28,18 +28,22 @@ import { Metric, MetricRecord, } from '@opentelemetry/metrics'; +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { CollectorMetricExporter } from '../../src/platform/browser/index'; +import * as collectorTypes from '../../src/types'; +import { CollectorExporterConfigBase } from '../../src/types'; import { - mockCounter, - mockObserver, ensureCounterIsCorrect, - ensureObserverIsCorrect, - ensureWebResourceIsCorrect, ensureExportMetricsServiceRequestIsSet, ensureHeadersContain, - mockValueRecorder, + ensureObserverIsCorrect, ensureValueRecorderIsCorrect, + ensureWebResourceIsCorrect, + mockCounter, + mockObserver, + mockValueRecorder, } from '../helper'; -import { hrTimeToNanoseconds } from '@opentelemetry/core'; const sendBeacon = navigator.sendBeacon; @@ -55,8 +59,8 @@ describe('CollectorMetricExporter - web', () => { spySend = sinon.stub(XMLHttpRequest.prototype, 'send'); spyBeacon = sinon.stub(navigator, 'sendBeacon'); metrics = []; - const counter: Metric & api.Counter = mockCounter(); - const observer: Metric & api.ValueObserver = mockObserver( + const counter: Metric & Counter = mockCounter(); + const observer: Metric & ValueObserver = mockObserver( observerResult => { observerResult.observe(3, {}); observerResult.observe(6, {}); @@ -64,7 +68,7 @@ describe('CollectorMetricExporter - web', () => { 'double-observer2' ); const recorder: Metric & - api.ValueRecorder = mockValueRecorder(); + ValueRecorder = mockValueRecorder(); counter.add(1); recorder.record(7); recorder.record(14); @@ -85,7 +89,7 @@ describe('CollectorMetricExporter - web', () => { describe('when "sendBeacon" is available', () => { beforeEach(() => { collectorExporter = new CollectorMetricExporter({ - logger: new api.NoopLogger(), + logger: new NoopLogger(), url: 'http://foo.bar.com', serviceName: 'bar', }); @@ -196,7 +200,7 @@ describe('CollectorMetricExporter - web', () => { beforeEach(() => { (window.navigator as any).sendBeacon = false; collectorExporter = new CollectorMetricExporter({ - logger: new api.NoopLogger(), + logger: new NoopLogger(), url: 'http://foo.bar.com', serviceName: 'bar', }); @@ -330,7 +334,7 @@ describe('CollectorMetricExporter - web', () => { beforeEach(() => { collectorExporterConfig = { - logger: new api.NoopLogger(), + logger: new NoopLogger(), headers: customHeaders, }; server = sinon.fakeServer.create(); diff --git a/packages/opentelemetry-exporter-collector/test/common/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector/test/common/CollectorMetricExporter.test.ts index fb1b7bb446f..b9a6ae2a54d 100644 --- a/packages/opentelemetry-exporter-collector/test/common/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/common/CollectorMetricExporter.test.ts @@ -14,20 +14,21 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { NoopLogger } from '@opentelemetry/api'; +import { Counter, ValueObserver } from '@opentelemetry/api-metrics'; import { ExportResultCode } from '@opentelemetry/core'; -import * as assert from 'assert'; -import * as sinon from 'sinon'; -import { CollectorExporterBase } from '../../src/CollectorExporterBase'; -import { CollectorExporterConfigBase } from '../../src/types'; import { BoundCounter, BoundObserver, Metric, MetricRecord, } from '@opentelemetry/metrics'; -import { mockCounter, mockObserver } from '../helper'; +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { CollectorExporterBase } from '../../src/CollectorExporterBase'; import * as collectorTypes from '../../src/types'; +import { CollectorExporterConfigBase } from '../../src/types'; +import { mockCounter, mockObserver } from '../helper'; type CollectorExporterConfig = CollectorExporterConfigBase; class CollectorMetricExporter extends CollectorExporterBase< @@ -62,15 +63,15 @@ describe('CollectorMetricExporter - common', () => { onInitSpy = sinon.stub(CollectorMetricExporter.prototype, 'onInit'); collectorExporterConfig = { hostname: 'foo', - logger: new api.NoopLogger(), + logger: new NoopLogger(), serviceName: 'bar', attributes: {}, url: 'http://foo.bar.com', }; collectorExporter = new CollectorMetricExporter(collectorExporterConfig); metrics = []; - const counter: Metric & api.Counter = mockCounter(); - const observer: Metric & api.ValueObserver = mockObserver( + const counter: Metric & Counter = mockCounter(); + const observer: Metric & ValueObserver = mockObserver( observerResult => { observerResult.observe(3, {}); observerResult.observe(6, {}); @@ -126,7 +127,7 @@ describe('CollectorMetricExporter - common', () => { }); it('should set default logger', () => { - assert.ok(collectorExporter.logger instanceof api.NoopLogger); + assert.ok(collectorExporter.logger instanceof NoopLogger); }); }); }); @@ -212,7 +213,7 @@ describe('CollectorMetricExporter - common', () => { ); collectorExporterConfig = { hostname: 'foo', - logger: new api.NoopLogger(), + logger: new NoopLogger(), serviceName: 'bar', attributes: {}, url: 'http://foo.bar.com', diff --git a/packages/opentelemetry-exporter-collector/test/common/transformMetrics.test.ts b/packages/opentelemetry-exporter-collector/test/common/transformMetrics.test.ts index 1b89f896684..30ede3ffd2f 100644 --- a/packages/opentelemetry-exporter-collector/test/common/transformMetrics.test.ts +++ b/packages/opentelemetry-exporter-collector/test/common/transformMetrics.test.ts @@ -13,45 +13,51 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +import { + Counter, + SumObserver, + UpDownSumObserver, + ValueObserver, + ValueRecorder, +} from '@opentelemetry/api-metrics'; +import { hrTimeToNanoseconds } from '@opentelemetry/core'; +import { + BoundCounter, + BoundObserver, + BoundValueRecorder, + Metric, + SumAggregator, +} from '@opentelemetry/metrics'; +import { Resource } from '@opentelemetry/resources'; import * as assert from 'assert'; import * as transform from '../../src/transformMetrics'; import { - mockCounter, - mockDoubleCounter, - mockObserver, ensureCounterIsCorrect, ensureDoubleCounterIsCorrect, ensureObserverIsCorrect, + ensureSumObserverIsCorrect, + ensureUpDownSumObserverIsCorrect, ensureValueRecorderIsCorrect, - mockValueRecorder, - mockedResources, + mockCounter, + mockDoubleCounter, mockedInstrumentationLibraries, - multiResourceMetricsGet, - multiInstrumentationLibraryMetricsGet, + mockedResources, + mockObserver, mockSumObserver, mockUpDownSumObserver, - ensureSumObserverIsCorrect, - ensureUpDownSumObserverIsCorrect, + mockValueRecorder, + multiInstrumentationLibraryMetricsGet, + multiResourceMetricsGet, } from '../helper'; -import { - BoundCounter, - BoundObserver, - BoundValueRecorder, - Metric, - SumAggregator, -} from '@opentelemetry/metrics'; -import { hrTimeToNanoseconds } from '@opentelemetry/core'; -import { Resource } from '@opentelemetry/resources'; -import * as api from '@opentelemetry/api'; describe('transformMetrics', () => { describe('toCollectorMetric', async () => { - let counter: Metric & api.Counter; - let doubleCounter: Metric & api.Counter; - let observer: Metric & api.ValueObserver; - let sumObserver: Metric & api.SumObserver; - let upDownSumObserver: Metric & api.UpDownSumObserver; - let recorder: Metric & api.ValueRecorder; + let counter: Metric & Counter; + let doubleCounter: Metric & Counter; + let observer: Metric & ValueObserver; + let sumObserver: Metric & SumObserver; + let upDownSumObserver: Metric & UpDownSumObserver; + let recorder: Metric & ValueRecorder; beforeEach(() => { counter = mockCounter(); doubleCounter = mockDoubleCounter(); diff --git a/packages/opentelemetry-exporter-collector/test/helper.ts b/packages/opentelemetry-exporter-collector/test/helper.ts index 1d45c2dfaf4..922674b346f 100644 --- a/packages/opentelemetry-exporter-collector/test/helper.ts +++ b/packages/opentelemetry-exporter-collector/test/helper.ts @@ -14,14 +14,23 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { StatusCode, TraceFlags } from '@opentelemetry/api'; +import { + Counter, + ObserverResult, + SumObserver, + UpDownSumObserver, + ValueObserver, + ValueRecorder, + ValueType, +} from '@opentelemetry/api-metrics'; +import { hexToBase64, InstrumentationLibrary } from '@opentelemetry/core'; import * as metrics from '@opentelemetry/metrics'; -import { ReadableSpan } from '@opentelemetry/tracing'; import { Resource } from '@opentelemetry/resources'; -import { hexToBase64, InstrumentationLibrary } from '@opentelemetry/core'; +import { ReadableSpan } from '@opentelemetry/tracing'; import * as assert from 'assert'; -import { opentelemetryProto } from '../src/types'; import * as collectorTypes from '../src/types'; +import { opentelemetryProto } from '../src/types'; const meterProvider = new metrics.MeterProvider({ interval: 30000, @@ -42,14 +51,13 @@ if (typeof Buffer === 'undefined') { }; } -export function mockCounter(): metrics.Metric & - api.Counter { +export function mockCounter(): metrics.Metric & Counter { const name = 'int-counter'; const metric = meter['_metrics'].get(name) || meter.createCounter(name, { description: 'sample counter description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, }); metric.clear(); metric.bind({}); @@ -57,13 +65,13 @@ export function mockCounter(): metrics.Metric & } export function mockDoubleCounter(): metrics.Metric & - api.Counter { + Counter { const name = 'double-counter'; const metric = meter['_metrics'].get(name) || meter.createCounter(name, { description: 'sample counter description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }); metric.clear(); metric.bind({}); @@ -71,16 +79,16 @@ export function mockDoubleCounter(): metrics.Metric & } export function mockObserver( - callback: (observerResult: api.ObserverResult) => unknown, + callback: (observerResult: ObserverResult) => unknown, name = 'double-observer' -): metrics.Metric & api.ValueObserver { +): metrics.Metric & ValueObserver { const metric = meter['_metrics'].get(name) || meter.createValueObserver( name, { description: 'sample observer description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }, callback ); @@ -90,16 +98,16 @@ export function mockObserver( } export function mockSumObserver( - callback: (observerResult: api.ObserverResult) => unknown, + callback: (observerResult: ObserverResult) => unknown, name = 'double-sum-observer' -): metrics.Metric & api.SumObserver { +): metrics.Metric & SumObserver { const metric = meter['_metrics'].get(name) || meter.createSumObserver( name, { description: 'sample sum observer description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }, callback ); @@ -109,16 +117,16 @@ export function mockSumObserver( } export function mockUpDownSumObserver( - callback: (observerResult: api.ObserverResult) => unknown, + callback: (observerResult: ObserverResult) => unknown, name = 'double-up-down-sum-observer' -): metrics.Metric & api.UpDownSumObserver { +): metrics.Metric & UpDownSumObserver { const metric = meter['_metrics'].get(name) || meter.createUpDownSumObserver( name, { description: 'sample up down sum observer description', - valueType: api.ValueType.DOUBLE, + valueType: ValueType.DOUBLE, }, callback ); @@ -128,13 +136,13 @@ export function mockUpDownSumObserver( } export function mockValueRecorder(): metrics.Metric & - api.ValueRecorder { + ValueRecorder { const name = 'int-recorder'; const metric = meter['_metrics'].get(name) || meter.createValueRecorder(name, { description: 'sample recorder description', - valueType: api.ValueType.INT, + valueType: ValueType.INT, boundaries: [0, 100], }); metric.clear(); @@ -152,13 +160,13 @@ export const mockedReadableSpan: ReadableSpan = { spanContext: { traceId: '1f1008dc8e270e85c40a0d7c3939b278', spanId: '5e107261f64fa53e', - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: '78a8915098864388', startTime: [1574120165, 429803070], endTime: [1574120165, 438688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: { component: 'document-load' }, links: [ { @@ -223,13 +231,13 @@ export const basicTrace: ReadableSpan[] = [ spanContext: { traceId: '1f1008dc8e270e85c40a0d7c3939b278', spanId: '5e107261f64fa53e', - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: '78a8915098864388', startTime: [1574120165, 429803070], endTime: [1574120165, 438688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: {}, links: [], events: [], @@ -243,13 +251,13 @@ export const basicTrace: ReadableSpan[] = [ spanContext: { traceId: '1f1008dc8e270e85c40a0d7c3939b278', spanId: 'f64fa53e5e107261', - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: '78a8915098864388', startTime: [1575120165, 439803070], endTime: [1575120165, 448688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: {}, links: [], events: [], @@ -263,13 +271,13 @@ export const basicTrace: ReadableSpan[] = [ spanContext: { traceId: '1f1008dc8e270e85c40a0d7c3939b278', spanId: '07261f64fa53e5e1', - traceFlags: api.TraceFlags.SAMPLED, + traceFlags: TraceFlags.SAMPLED, }, parentSpanId: 'a891578098864388', startTime: [1575120165, 439803070], endTime: [1575120165, 448688070], ended: true, - status: { code: api.StatusCode.OK }, + status: { code: StatusCode.OK }, attributes: {}, links: [], events: [], @@ -295,7 +303,7 @@ export const multiResourceTrace: ReadableSpan[] = [ ]; export const multiResourceMetricsGet = function ( - callback: (observerResult: api.ObserverResult) => unknown + callback: (observerResult: ObserverResult) => unknown ): any[] { return [ { @@ -317,7 +325,7 @@ export const multiResourceMetricsGet = function ( }; export const multiInstrumentationLibraryMetricsGet = function ( - callback: (observerResult: api.ObserverResult) => unknown + callback: (observerResult: ObserverResult) => unknown ): any[] { return [ { diff --git a/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts index 42c22976825..3c7233f71b8 100644 --- a/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts @@ -14,33 +14,38 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { NoopLogger } from '@opentelemetry/api'; +import { + Counter, + ValueObserver, + ValueRecorder, +} from '@opentelemetry/api-metrics'; import * as core from '@opentelemetry/core'; -import * as http from 'http'; +import { + BoundCounter, + BoundObserver, + BoundValueRecorder, + Metric, + MetricRecord, +} from '@opentelemetry/metrics'; import * as assert from 'assert'; +import * as http from 'http'; import * as sinon from 'sinon'; import { - CollectorMetricExporter, CollectorExporterNodeConfigBase, + CollectorMetricExporter, } from '../../src/platform/node'; import * as collectorTypes from '../../src/types'; -import { MockedResponse } from './nodeHelpers'; import { + ensureCounterIsCorrect, + ensureExportMetricsServiceRequestIsSet, + ensureObserverIsCorrect, + ensureValueRecorderIsCorrect, mockCounter, mockObserver, - ensureExportMetricsServiceRequestIsSet, - ensureCounterIsCorrect, mockValueRecorder, - ensureValueRecorderIsCorrect, - ensureObserverIsCorrect, } from '../helper'; -import { - BoundCounter, - BoundObserver, - BoundValueRecorder, - Metric, - MetricRecord, -} from '@opentelemetry/metrics'; +import { MockedResponse } from './nodeHelpers'; const fakeRequest = { end: function () {}, @@ -81,7 +86,7 @@ describe('CollectorMetricExporter - node with json over http', () => { foo: 'bar', }, hostname: 'foo', - logger: new api.NoopLogger(), + logger: new NoopLogger(), serviceName: 'bar', attributes: {}, url: 'http://foo.bar.com', @@ -94,15 +99,15 @@ describe('CollectorMetricExporter - node with json over http', () => { value: 1592602232694000000, }); metrics = []; - const counter: Metric & api.Counter = mockCounter(); - const observer: Metric & api.ValueObserver = mockObserver( + const counter: Metric & Counter = mockCounter(); + const observer: Metric & ValueObserver = mockObserver( observerResult => { observerResult.observe(6, {}); }, 'double-observer2' ); const recorder: Metric & - api.ValueRecorder = mockValueRecorder(); + ValueRecorder = mockValueRecorder(); counter.add(1); recorder.record(7); recorder.record(14); diff --git a/packages/opentelemetry-exporter-collector/tsconfig.json b/packages/opentelemetry-exporter-collector/tsconfig.json index 4410230d449..c31181cd6fd 100644 --- a/packages/opentelemetry-exporter-collector/tsconfig.json +++ b/packages/opentelemetry-exporter-collector/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-core" }, diff --git a/packages/opentelemetry-exporter-prometheus/package.json b/packages/opentelemetry-exporter-prometheus/package.json index 06b9a6f8888..8efa0eb3672 100644 --- a/packages/opentelemetry-exporter-prometheus/package.json +++ b/packages/opentelemetry-exporter-prometheus/package.json @@ -52,6 +52,7 @@ }, "dependencies": { "@opentelemetry/api": "^0.14.0", + "@opentelemetry/api-metrics": "^0.14.0", "@opentelemetry/core": "^0.14.0", "@opentelemetry/metrics": "^0.14.0" } diff --git a/packages/opentelemetry-exporter-prometheus/src/PrometheusSerializer.ts b/packages/opentelemetry-exporter-prometheus/src/PrometheusSerializer.ts index 7a35fae140d..45b1abdad48 100644 --- a/packages/opentelemetry-exporter-prometheus/src/PrometheusSerializer.ts +++ b/packages/opentelemetry-exporter-prometheus/src/PrometheusSerializer.ts @@ -19,7 +19,7 @@ import { MetricKind, } from '@opentelemetry/metrics'; import { PrometheusCheckpoint } from './types'; -import { Labels } from '@opentelemetry/api'; +import { Labels } from '@opentelemetry/api-metrics'; import { hrTimeToMilliseconds } from '@opentelemetry/core'; type PrometheusDataTypeLiteral = diff --git a/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts b/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts index 28da5cf48fc..cb5ccb93bca 100644 --- a/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts +++ b/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import { ObserverResult } from '@opentelemetry/api'; +import { ObserverResult } from '@opentelemetry/api-metrics'; import { CounterMetric, SumAggregator, diff --git a/packages/opentelemetry-exporter-prometheus/test/PrometheusLabelsBatcher.test.ts b/packages/opentelemetry-exporter-prometheus/test/PrometheusLabelsBatcher.test.ts index 27a500700b5..1a728800496 100644 --- a/packages/opentelemetry-exporter-prometheus/test/PrometheusLabelsBatcher.test.ts +++ b/packages/opentelemetry-exporter-prometheus/test/PrometheusLabelsBatcher.test.ts @@ -21,7 +21,7 @@ import { MeterProvider, Meter, } from '@opentelemetry/metrics'; -import { Labels } from '@opentelemetry/api'; +import { Labels } from '@opentelemetry/api-metrics'; describe('PrometheusBatcher', () => { let meter: Meter; diff --git a/packages/opentelemetry-exporter-prometheus/test/PrometheusSerializer.test.ts b/packages/opentelemetry-exporter-prometheus/test/PrometheusSerializer.test.ts index 038924ccdf5..4495154f921 100644 --- a/packages/opentelemetry-exporter-prometheus/test/PrometheusSerializer.test.ts +++ b/packages/opentelemetry-exporter-prometheus/test/PrometheusSerializer.test.ts @@ -24,7 +24,7 @@ import { ValueObserverMetric, } from '@opentelemetry/metrics'; import * as assert from 'assert'; -import { Labels } from '@opentelemetry/api'; +import { Labels } from '@opentelemetry/api-metrics'; import { PrometheusSerializer } from '../src/PrometheusSerializer'; import { PrometheusLabelsBatcher } from '../src/PrometheusLabelsBatcher'; import { ExactProcessor } from './ExactProcessor'; diff --git a/packages/opentelemetry-exporter-prometheus/tsconfig.json b/packages/opentelemetry-exporter-prometheus/tsconfig.json index 42b254c5492..59d79ed095d 100644 --- a/packages/opentelemetry-exporter-prometheus/tsconfig.json +++ b/packages/opentelemetry-exporter-prometheus/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-core" }, diff --git a/packages/opentelemetry-instrumentation/package.json b/packages/opentelemetry-instrumentation/package.json index 7d878e2d78f..ed4636becd8 100644 --- a/packages/opentelemetry-instrumentation/package.json +++ b/packages/opentelemetry-instrumentation/package.json @@ -55,6 +55,7 @@ }, "dependencies": { "@opentelemetry/api": "^0.14.0", + "@opentelemetry/api-metrics": "^0.14.0", "require-in-the-middle": "^5.0.3", "semver": "^7.3.2", "shimmer": "^1.2.1" diff --git a/packages/opentelemetry-instrumentation/src/autoLoader.ts b/packages/opentelemetry-instrumentation/src/autoLoader.ts index 24dc70e99ce..aecef78c99f 100644 --- a/packages/opentelemetry-instrumentation/src/autoLoader.ts +++ b/packages/opentelemetry-instrumentation/src/autoLoader.ts @@ -15,6 +15,7 @@ */ import * as api from '@opentelemetry/api'; +import { metrics } from '@opentelemetry/api-metrics'; import { disableInstrumentations, enableInstrumentations, @@ -42,7 +43,7 @@ export function registerInstrumentations( }; const tracerProvider = options.tracerProvider || api.trace.getTracerProvider(); - const meterProvider = options.meterProvider || api.metrics.getMeterProvider(); + const meterProvider = options.meterProvider || metrics.getMeterProvider(); const logger = options.logger || tracerWithLogger?.logger || new api.NoopLogger(); diff --git a/packages/opentelemetry-instrumentation/src/autoLoaderUtils.ts b/packages/opentelemetry-instrumentation/src/autoLoaderUtils.ts index 4d0660478a7..cb95c9c9c52 100644 --- a/packages/opentelemetry-instrumentation/src/autoLoaderUtils.ts +++ b/packages/opentelemetry-instrumentation/src/autoLoaderUtils.ts @@ -14,10 +14,10 @@ * limitations under the License. */ -import { Logger, MeterProvider, TracerProvider } from '@opentelemetry/api'; +import { Logger, TracerProvider } from '@opentelemetry/api'; +import { MeterProvider } from '@opentelemetry/api-metrics'; import { Instrumentation } from './types'; import { AutoLoaderResult, InstrumentationOption } from './types_internal'; - import { NodePlugins, NodePluginsTracerConfiguration, diff --git a/packages/opentelemetry-instrumentation/src/instrumentation.ts b/packages/opentelemetry-instrumentation/src/instrumentation.ts index 72748d4e402..080a6a94ee7 100644 --- a/packages/opentelemetry-instrumentation/src/instrumentation.ts +++ b/packages/opentelemetry-instrumentation/src/instrumentation.ts @@ -15,6 +15,7 @@ */ import * as api from '@opentelemetry/api'; +import { Meter, MeterProvider, metrics } from '@opentelemetry/api-metrics'; import * as shimmer from 'shimmer'; import { InstrumentationModuleDefinition } from './platform/node'; import * as types from './types'; @@ -27,7 +28,7 @@ export abstract class InstrumentationAbstract protected _config: types.InstrumentationConfig; private _tracer: api.Tracer; - private _meter: api.Meter; + private _meter: Meter; protected _logger: api.Logger; constructor( @@ -46,10 +47,7 @@ export abstract class InstrumentationAbstract instrumentationVersion ); - this._meter = api.metrics.getMeter( - instrumentationName, - instrumentationVersion - ); + this._meter = metrics.getMeter(instrumentationName, instrumentationVersion); } /* Api to wrap instrumented method */ @@ -62,7 +60,7 @@ export abstract class InstrumentationAbstract protected _massUnwrap = shimmer.massUnwrap; /* Returns meter */ - protected get meter(): api.Meter { + protected get meter(): Meter { return this._meter; } @@ -70,7 +68,7 @@ export abstract class InstrumentationAbstract * Sets MeterProvider to this plugin * @param meterProvider */ - public setMeterProvider(meterProvider: api.MeterProvider) { + public setMeterProvider(meterProvider: MeterProvider) { this._meter = meterProvider.getMeter( this.instrumentationName, this.instrumentationVersion diff --git a/packages/opentelemetry-instrumentation/src/types.ts b/packages/opentelemetry-instrumentation/src/types.ts index a6501d3aad2..e0eaa025919 100644 --- a/packages/opentelemetry-instrumentation/src/types.ts +++ b/packages/opentelemetry-instrumentation/src/types.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { Logger, MeterProvider, TracerProvider } from '@opentelemetry/api'; +import { Logger, TracerProvider } from '@opentelemetry/api'; +import { MeterProvider } from '@opentelemetry/api-metrics'; /** Interface Instrumentation to apply patch. */ export interface Instrumentation { diff --git a/packages/opentelemetry-instrumentation/src/types_internal.ts b/packages/opentelemetry-instrumentation/src/types_internal.ts index 49a328db817..be4399433d5 100644 --- a/packages/opentelemetry-instrumentation/src/types_internal.ts +++ b/packages/opentelemetry-instrumentation/src/types_internal.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { Logger, MeterProvider, TracerProvider } from '@opentelemetry/api'; +import { Logger, TracerProvider } from '@opentelemetry/api'; +import { MeterProvider } from '@opentelemetry/api-metrics'; import { InstrumentationBase } from './platform'; import { Instrumentation } from './types'; import { diff --git a/packages/opentelemetry-instrumentation/test/browser/autoLoader.test.ts b/packages/opentelemetry-instrumentation/test/browser/autoLoader.test.ts index 1f3e6d5cc69..cc9e15edef6 100644 --- a/packages/opentelemetry-instrumentation/test/browser/autoLoader.test.ts +++ b/packages/opentelemetry-instrumentation/test/browser/autoLoader.test.ts @@ -14,12 +14,11 @@ * limitations under the License. */ -import { NOOP_METER_PROVIDER, NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_METER_PROVIDER } from '@opentelemetry/api-metrics'; import * as assert from 'assert'; import * as sinon from 'sinon'; - import { registerInstrumentations } from '../../src'; - import { OldClassPlugin } from '../../src/types_plugin_only'; class WebPlugin implements OldClassPlugin { diff --git a/packages/opentelemetry-instrumentation/test/common/autoLoader.test.ts b/packages/opentelemetry-instrumentation/test/common/autoLoader.test.ts index 6916c611575..3a1abd88615 100644 --- a/packages/opentelemetry-instrumentation/test/common/autoLoader.test.ts +++ b/packages/opentelemetry-instrumentation/test/common/autoLoader.test.ts @@ -14,10 +14,10 @@ * limitations under the License. */ -import { NOOP_METER_PROVIDER, NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_METER_PROVIDER } from '@opentelemetry/api-metrics'; import * as assert from 'assert'; import * as sinon from 'sinon'; - import { InstrumentationBase, registerInstrumentations } from '../../src'; class FooInstrumentation extends InstrumentationBase { diff --git a/packages/opentelemetry-instrumentation/test/node/autoLoader.test.ts b/packages/opentelemetry-instrumentation/test/node/autoLoader.test.ts index 5e14c2424e8..45877024457 100644 --- a/packages/opentelemetry-instrumentation/test/node/autoLoader.test.ts +++ b/packages/opentelemetry-instrumentation/test/node/autoLoader.test.ts @@ -14,11 +14,11 @@ * limitations under the License. */ -import { NOOP_METER_PROVIDER, NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_TRACER_PROVIDER } from '@opentelemetry/api'; +import { NOOP_METER_PROVIDER } from '@opentelemetry/api-metrics'; import * as assert from 'assert'; import * as path from 'path'; import * as sinon from 'sinon'; - import { registerInstrumentations } from '../../src'; import { Plugins, diff --git a/packages/opentelemetry-instrumentation/tsconfig.json b/packages/opentelemetry-instrumentation/tsconfig.json index e73d377644e..8a9fb20b7a7 100644 --- a/packages/opentelemetry-instrumentation/tsconfig.json +++ b/packages/opentelemetry-instrumentation/tsconfig.json @@ -11,6 +11,9 @@ "references": [ { "path": "../opentelemetry-api" + }, + { + "path": "../opentelemetry-api-metrics" } ] } diff --git a/packages/opentelemetry-metrics/package.json b/packages/opentelemetry-metrics/package.json index 1bcb8395913..e3d75bc8247 100644 --- a/packages/opentelemetry-metrics/package.json +++ b/packages/opentelemetry-metrics/package.json @@ -56,6 +56,7 @@ }, "dependencies": { "@opentelemetry/api": "^0.14.0", + "@opentelemetry/api-metrics": "^0.14.0", "@opentelemetry/core": "^0.14.0", "@opentelemetry/resources": "^0.14.0", "lodash.merge": "^4.6.2" diff --git a/packages/opentelemetry-metrics/src/BaseObserverMetric.ts b/packages/opentelemetry-metrics/src/BaseObserverMetric.ts index 0b10f60ec39..82df5a507e6 100644 --- a/packages/opentelemetry-metrics/src/BaseObserverMetric.ts +++ b/packages/opentelemetry-metrics/src/BaseObserverMetric.ts @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BoundObserver } from './BoundInstrument'; diff --git a/packages/opentelemetry-metrics/src/BatchObserver.ts b/packages/opentelemetry-metrics/src/BatchObserver.ts index 5663c8d08f9..531b152e0e0 100644 --- a/packages/opentelemetry-metrics/src/BatchObserver.ts +++ b/packages/opentelemetry-metrics/src/BatchObserver.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { Logger, NoopLogger } from '@opentelemetry/api'; import { BatchObserverResult } from './BatchObserverResult'; import { MetricRecord } from './export/types'; diff --git a/packages/opentelemetry-metrics/src/BatchObserverResult.ts b/packages/opentelemetry-metrics/src/BatchObserverResult.ts index 2d0e7be4d53..da6d5367e04 100644 --- a/packages/opentelemetry-metrics/src/BatchObserverResult.ts +++ b/packages/opentelemetry-metrics/src/BatchObserverResult.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; /** * Implementation of api BatchObserverResult diff --git a/packages/opentelemetry-metrics/src/BoundInstrument.ts b/packages/opentelemetry-metrics/src/BoundInstrument.ts index e84bb724876..6a70d72848a 100644 --- a/packages/opentelemetry-metrics/src/BoundInstrument.ts +++ b/packages/opentelemetry-metrics/src/BoundInstrument.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { Logger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { Aggregator } from './export/types'; /** @@ -23,11 +24,11 @@ import { Aggregator } from './export/types'; */ export class BaseBoundInstrument { protected _labels: api.Labels; - protected _logger: api.Logger; + protected _logger: Logger; constructor( labels: api.Labels, - logger: api.Logger, + logger: Logger, private readonly _disabled: boolean, private readonly _valueType: api.ValueType, private readonly _aggregator: Aggregator @@ -79,7 +80,7 @@ export class BoundCounter labels: api.Labels, disabled: boolean, valueType: api.ValueType, - logger: api.Logger, + logger: Logger, aggregator: Aggregator ) { super(labels, logger, disabled, valueType, aggregator); @@ -109,7 +110,7 @@ export class BoundUpDownCounter labels: api.Labels, disabled: boolean, valueType: api.ValueType, - logger: api.Logger, + logger: Logger, aggregator: Aggregator ) { super(labels, logger, disabled, valueType, aggregator); @@ -130,7 +131,7 @@ export class BoundValueRecorder labels: api.Labels, disabled: boolean, valueType: api.ValueType, - logger: api.Logger, + logger: Logger, aggregator: Aggregator ) { super(labels, logger, disabled, valueType, aggregator); @@ -151,7 +152,7 @@ export class BoundObserver labels: api.Labels, disabled: boolean, valueType: api.ValueType, - logger: api.Logger, + logger: Logger, aggregator: Aggregator ) { super(labels, logger, disabled, valueType, aggregator); diff --git a/packages/opentelemetry-metrics/src/CounterMetric.ts b/packages/opentelemetry-metrics/src/CounterMetric.ts index 5407ffbc6ae..d9150f26cdb 100644 --- a/packages/opentelemetry-metrics/src/CounterMetric.ts +++ b/packages/opentelemetry-metrics/src/CounterMetric.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BoundCounter } from './BoundInstrument'; diff --git a/packages/opentelemetry-metrics/src/Meter.ts b/packages/opentelemetry-metrics/src/Meter.ts index ebc4ead0160..7bd7c22a41f 100644 --- a/packages/opentelemetry-metrics/src/Meter.ts +++ b/packages/opentelemetry-metrics/src/Meter.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { Logger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { ConsoleLogger, InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BatchObserver } from './BatchObserver'; @@ -36,7 +37,7 @@ import merge = require('lodash.merge'); * Meter is an implementation of the {@link Meter} interface. */ export class Meter implements api.Meter { - private readonly _logger: api.Logger; + private readonly _logger: Logger; private readonly _batchObservers: BatchObserver[] = []; private readonly _metrics = new Map>(); private readonly _processor: Processor; diff --git a/packages/opentelemetry-metrics/src/MeterProvider.ts b/packages/opentelemetry-metrics/src/MeterProvider.ts index e28135f31ed..e3778cee67b 100644 --- a/packages/opentelemetry-metrics/src/MeterProvider.ts +++ b/packages/opentelemetry-metrics/src/MeterProvider.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { Logger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { ConsoleLogger } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { Meter } from '.'; @@ -30,7 +31,7 @@ export class MeterProvider implements api.MeterProvider { private _shuttingDownPromise: Promise = Promise.resolve(); private _isShutdown = false; readonly resource: Resource; - readonly logger: api.Logger; + readonly logger: Logger; constructor(config: MeterConfig = {}) { const mergedConfig = merge({}, DEFAULT_CONFIG, config); diff --git a/packages/opentelemetry-metrics/src/Metric.ts b/packages/opentelemetry-metrics/src/Metric.ts index 525c166d765..cc88f369d53 100644 --- a/packages/opentelemetry-metrics/src/Metric.ts +++ b/packages/opentelemetry-metrics/src/Metric.ts @@ -13,19 +13,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import { Logger, NoopLogger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; +import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BaseBoundInstrument } from './BoundInstrument'; import { MetricDescriptor, MetricKind, MetricRecord } from './export/types'; import { hashLabels } from './Utils'; -import { InstrumentationLibrary } from '@opentelemetry/core'; /** This is a SDK implementation of {@link Metric} interface. */ export abstract class Metric implements api.UnboundMetric { protected readonly _disabled: boolean; protected readonly _valueType: api.ValueType; - protected readonly _logger: api.Logger; + protected readonly _logger: Logger; protected readonly _descriptor: MetricDescriptor; protected readonly _boundaries: number[] | undefined; private readonly _instruments: Map = new Map(); @@ -42,7 +43,7 @@ export abstract class Metric typeof _options.valueType === 'number' ? _options.valueType : api.ValueType.DOUBLE; - this._logger = _options.logger ?? new api.NoopLogger(); + this._logger = _options.logger ?? new NoopLogger(); this._boundaries = _options.boundaries; this._descriptor = this._getMetricDescriptor(); } diff --git a/packages/opentelemetry-metrics/src/ObserverResult.ts b/packages/opentelemetry-metrics/src/ObserverResult.ts index 60d555641f9..60dcc044493 100644 --- a/packages/opentelemetry-metrics/src/ObserverResult.ts +++ b/packages/opentelemetry-metrics/src/ObserverResult.ts @@ -17,7 +17,7 @@ import { ObserverResult as TypeObserverResult, Labels, -} from '@opentelemetry/api'; +} from '@opentelemetry/api-metrics'; /** * Implementation of {@link TypeObserverResult} diff --git a/packages/opentelemetry-metrics/src/SumObserverMetric.ts b/packages/opentelemetry-metrics/src/SumObserverMetric.ts index 48a198ff9b6..2f4c723ec90 100644 --- a/packages/opentelemetry-metrics/src/SumObserverMetric.ts +++ b/packages/opentelemetry-metrics/src/SumObserverMetric.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BaseObserverMetric } from './BaseObserverMetric'; diff --git a/packages/opentelemetry-metrics/src/UpDownCounterMetric.ts b/packages/opentelemetry-metrics/src/UpDownCounterMetric.ts index 5d019e09c4a..cac09f0c91b 100644 --- a/packages/opentelemetry-metrics/src/UpDownCounterMetric.ts +++ b/packages/opentelemetry-metrics/src/UpDownCounterMetric.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { Resource } from '@opentelemetry/resources'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { BoundUpDownCounter } from './BoundInstrument'; diff --git a/packages/opentelemetry-metrics/src/UpDownSumObserverMetric.ts b/packages/opentelemetry-metrics/src/UpDownSumObserverMetric.ts index fe8f3ce6e5a..31cec8af7a5 100644 --- a/packages/opentelemetry-metrics/src/UpDownSumObserverMetric.ts +++ b/packages/opentelemetry-metrics/src/UpDownSumObserverMetric.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BaseObserverMetric } from './BaseObserverMetric'; diff --git a/packages/opentelemetry-metrics/src/Utils.ts b/packages/opentelemetry-metrics/src/Utils.ts index de9e9eabfa1..6b0fa1503d0 100644 --- a/packages/opentelemetry-metrics/src/Utils.ts +++ b/packages/opentelemetry-metrics/src/Utils.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import { Labels } from '@opentelemetry/api'; +import { Labels } from '@opentelemetry/api-metrics'; /** * Type guard to remove nulls from arrays diff --git a/packages/opentelemetry-metrics/src/ValueObserverMetric.ts b/packages/opentelemetry-metrics/src/ValueObserverMetric.ts index 9c20883247a..a7ac5c5ff59 100644 --- a/packages/opentelemetry-metrics/src/ValueObserverMetric.ts +++ b/packages/opentelemetry-metrics/src/ValueObserverMetric.ts @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BaseObserverMetric } from './BaseObserverMetric'; diff --git a/packages/opentelemetry-metrics/src/ValueRecorderMetric.ts b/packages/opentelemetry-metrics/src/ValueRecorderMetric.ts index cb732d1aef6..cf80e876b82 100644 --- a/packages/opentelemetry-metrics/src/ValueRecorderMetric.ts +++ b/packages/opentelemetry-metrics/src/ValueRecorderMetric.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import * as api from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import { InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { BoundValueRecorder } from './BoundInstrument'; diff --git a/packages/opentelemetry-metrics/src/export/types.ts b/packages/opentelemetry-metrics/src/export/types.ts index c5d3c8e6202..b28ce79640a 100644 --- a/packages/opentelemetry-metrics/src/export/types.ts +++ b/packages/opentelemetry-metrics/src/export/types.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { ValueType, HrTime, Labels } from '@opentelemetry/api'; +import { HrTime } from '@opentelemetry/api'; +import { Labels, ValueType } from '@opentelemetry/api-metrics'; import { ExportResult, InstrumentationLibrary } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; diff --git a/packages/opentelemetry-metrics/src/types.ts b/packages/opentelemetry-metrics/src/types.ts index 0ff56102012..bc063dc70f5 100644 --- a/packages/opentelemetry-metrics/src/types.ts +++ b/packages/opentelemetry-metrics/src/types.ts @@ -14,16 +14,17 @@ * limitations under the License. */ -import { LogLevel, getEnv } from '@opentelemetry/core'; -import * as api from '@opentelemetry/api'; +import { Logger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; +import { getEnv, LogLevel } from '@opentelemetry/core'; +import { Resource } from '@opentelemetry/resources'; import { Processor } from './export/Processor'; import { MetricExporter } from './export/types'; -import { Resource } from '@opentelemetry/resources'; /** MeterConfig provides an interface for configuring a Meter. */ export interface MeterConfig { /** User provided logger. */ - logger?: api.Logger; + logger?: Logger; /** level of logger. */ logLevel?: LogLevel; diff --git a/packages/opentelemetry-metrics/test/Meter.test.ts b/packages/opentelemetry-metrics/test/Meter.test.ts index 2a9562cd871..e4ffdc98834 100644 --- a/packages/opentelemetry-metrics/test/Meter.test.ts +++ b/packages/opentelemetry-metrics/test/Meter.test.ts @@ -14,36 +14,36 @@ * limitations under the License. */ +import { NoopLogger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; +import { hrTime, hrTimeToNanoseconds } from '@opentelemetry/core'; +import { Resource } from '@opentelemetry/resources'; import * as assert from 'assert'; import * as sinon from 'sinon'; import { + Aggregator, + CounterMetric, + Histogram, + LastValue, + LastValueAggregator, Meter, + MeterProvider, Metric, - CounterMetric, + MetricDescriptor, MetricKind, - Sum, - MeterProvider, - ValueRecorderMetric, - ValueObserverMetric, MetricRecord, - Aggregator, - MetricDescriptor, + Sum, UpDownCounterMetric, - LastValueAggregator, - LastValue, - Histogram, + ValueObserverMetric, + ValueRecorderMetric, } from '../src'; -import * as api from '@opentelemetry/api'; -import { hrTime, hrTimeToNanoseconds } from '@opentelemetry/core'; +import { BatchObserver } from '../src/BatchObserver'; import { BatchObserverResult } from '../src/BatchObserverResult'; import { SumAggregator } from '../src/export/aggregators'; +import { Processor } from '../src/export/Processor'; import { SumObserverMetric } from '../src/SumObserverMetric'; -import { Resource } from '@opentelemetry/resources'; import { UpDownSumObserverMetric } from '../src/UpDownSumObserverMetric'; import { hashLabels } from '../src/Utils'; -import { Processor } from '../src/export/Processor'; -import { ValueType } from '@opentelemetry/api'; -import { BatchObserver } from '../src/BatchObserver'; const nonNumberValues = [ // type undefined @@ -81,7 +81,7 @@ describe('Meter', () => { beforeEach(() => { meter = new MeterProvider({ - logger: new api.NoopLogger(), + logger: new NoopLogger(), }).getMeter('test-meter'); }); @@ -408,7 +408,7 @@ describe('Meter', () => { it('should truncate non-integer values for INT valueType', async () => { const upDownCounter = meter.createUpDownCounter('name', { - valueType: ValueType.INT, + valueType: api.ValueType.INT, }); const boundCounter = upDownCounter.bind(labels); @@ -422,7 +422,7 @@ describe('Meter', () => { it('should ignore non-number values for INT valueType', async () => { const upDownCounter = meter.createUpDownCounter('name', { - valueType: ValueType.DOUBLE, + valueType: api.ValueType.DOUBLE, }); const boundCounter = upDownCounter.bind(labels); @@ -440,7 +440,7 @@ describe('Meter', () => { it('should ignore non-number values for DOUBLE valueType', async () => { const upDownCounter = meter.createUpDownCounter('name', { - valueType: ValueType.DOUBLE, + valueType: api.ValueType.DOUBLE, }); const boundCounter = upDownCounter.bind(labels); diff --git a/packages/opentelemetry-metrics/test/Processor.test.ts b/packages/opentelemetry-metrics/test/Processor.test.ts index d14bd4fe5a0..a766a93a149 100644 --- a/packages/opentelemetry-metrics/test/Processor.test.ts +++ b/packages/opentelemetry-metrics/test/Processor.test.ts @@ -14,8 +14,9 @@ * limitations under the License. */ +import { NoopLogger } from '@opentelemetry/api'; +import * as api from '@opentelemetry/api-metrics'; import * as assert from 'assert'; -import * as api from '@opentelemetry/api'; import { Meter, MeterProvider } from '../src'; describe('Processor', () => { @@ -26,7 +27,7 @@ describe('Processor', () => { let counter: api.Counter; beforeEach(() => { meter = new MeterProvider({ - logger: new api.NoopLogger(), + logger: new NoopLogger(), interval: 10000, }).getMeter('test-meter'); counter = meter.createCounter('ungrouped-processor-test'); diff --git a/packages/opentelemetry-metrics/test/export/ConsoleMetricExporter.test.ts b/packages/opentelemetry-metrics/test/export/ConsoleMetricExporter.test.ts index a9b516f40c3..cf915fbcebe 100644 --- a/packages/opentelemetry-metrics/test/export/ConsoleMetricExporter.test.ts +++ b/packages/opentelemetry-metrics/test/export/ConsoleMetricExporter.test.ts @@ -17,7 +17,7 @@ import * as assert from 'assert'; import * as sinon from 'sinon'; import { ConsoleMetricExporter, MeterProvider, MetricKind } from '../../src'; -import { ValueType } from '@opentelemetry/api'; +import { ValueType } from '@opentelemetry/api-metrics'; describe('ConsoleMetricExporter', () => { let consoleExporter: ConsoleMetricExporter; diff --git a/packages/opentelemetry-metrics/tsconfig.json b/packages/opentelemetry-metrics/tsconfig.json index 954354a3a00..e14e1c1b7f7 100644 --- a/packages/opentelemetry-metrics/tsconfig.json +++ b/packages/opentelemetry-metrics/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-core" }, diff --git a/packages/opentelemetry-sdk-node/package.json b/packages/opentelemetry-sdk-node/package.json index 075ee266059..58b5e2b5e4c 100644 --- a/packages/opentelemetry-sdk-node/package.json +++ b/packages/opentelemetry-sdk-node/package.json @@ -41,6 +41,7 @@ }, "dependencies": { "@opentelemetry/api": "^0.14.0", + "@opentelemetry/api-metrics": "^0.14.0", "@opentelemetry/context-base": "^0.14.0", "@opentelemetry/core": "^0.14.0", "@opentelemetry/metrics": "^0.14.0", diff --git a/packages/opentelemetry-sdk-node/src/sdk.ts b/packages/opentelemetry-sdk-node/src/sdk.ts index a25933998be..3290993f31d 100644 --- a/packages/opentelemetry-sdk-node/src/sdk.ts +++ b/packages/opentelemetry-sdk-node/src/sdk.ts @@ -14,21 +14,22 @@ * limitations under the License. */ -import { TextMapPropagator, metrics } from '@opentelemetry/api'; +import { TextMapPropagator } from '@opentelemetry/api'; +import { metrics } from '@opentelemetry/api-metrics'; import { ContextManager } from '@opentelemetry/context-base'; import { MeterConfig, MeterProvider } from '@opentelemetry/metrics'; import { NodeTracerConfig, NodeTracerProvider } from '@opentelemetry/node'; +import { awsEc2Detector } from '@opentelemetry/resource-detector-aws'; +import { gcpDetector } from '@opentelemetry/resource-detector-gcp'; import { detectResources, - Resource, - ResourceDetectionConfig, envDetector, processDetector, + Resource, + ResourceDetectionConfig, } from '@opentelemetry/resources'; import { BatchSpanProcessor, SpanProcessor } from '@opentelemetry/tracing'; import { NodeSDKConfiguration } from './types'; -import { awsEc2Detector } from '@opentelemetry/resource-detector-aws'; -import { gcpDetector } from '@opentelemetry/resource-detector-gcp'; /** This class represents everything needed to register a fully configured OpenTelemetry Node.js SDK */ export class NodeSDK { diff --git a/packages/opentelemetry-sdk-node/test/sdk.test.ts b/packages/opentelemetry-sdk-node/test/sdk.test.ts index c33e84cfb61..c5fbbdc7247 100644 --- a/packages/opentelemetry-sdk-node/test/sdk.test.ts +++ b/packages/opentelemetry-sdk-node/test/sdk.test.ts @@ -14,18 +14,15 @@ * limitations under the License. */ -import * as nock from 'nock'; -import * as semver from 'semver'; import { context, - metrics, NoopTextMapPropagator, - NoopMeterProvider, NoopTracerProvider, propagation, - trace, ProxyTracerProvider, + trace, } from '@opentelemetry/api'; +import { metrics, NoopMeterProvider } from '@opentelemetry/api-metrics'; import { AsyncHooksContextManager, AsyncLocalStorageContextManager, @@ -34,21 +31,20 @@ import { NoopContextManager } from '@opentelemetry/context-base'; import { CompositePropagator } from '@opentelemetry/core'; import { ConsoleMetricExporter, MeterProvider } from '@opentelemetry/metrics'; import { NodeTracerProvider } from '@opentelemetry/node'; -import { - ConsoleSpanExporter, - SimpleSpanProcessor, -} from '@opentelemetry/tracing'; -import * as assert from 'assert'; -import { NodeSDK } from '../src'; import * as NodeConfig from '@opentelemetry/node/build/src/config'; -import * as Sinon from 'sinon'; import { awsEc2Detector } from '@opentelemetry/resource-detector-aws'; import { resetIsAvailableCache } from '@opentelemetry/resource-detector-gcp'; +import { Resource } from '@opentelemetry/resources'; import { - assertServiceResource, assertCloudResource, assertHostResource, + assertServiceResource, } from '@opentelemetry/resources/test/util/resource-assertions'; +import { + ConsoleSpanExporter, + SimpleSpanProcessor, +} from '@opentelemetry/tracing'; +import * as assert from 'assert'; import { BASE_PATH, HEADER_NAME, @@ -56,7 +52,10 @@ import { HOST_ADDRESS, SECONDARY_HOST_ADDRESS, } from 'gcp-metadata'; -import { Resource } from '@opentelemetry/resources'; +import * as nock from 'nock'; +import * as semver from 'semver'; +import * as Sinon from 'sinon'; +import { NodeSDK } from '../src'; const HEADERS = { [HEADER_NAME.toLowerCase()]: HEADER_VALUE, diff --git a/packages/opentelemetry-sdk-node/tsconfig.json b/packages/opentelemetry-sdk-node/tsconfig.json index 544fb350f17..1656d30753b 100644 --- a/packages/opentelemetry-sdk-node/tsconfig.json +++ b/packages/opentelemetry-sdk-node/tsconfig.json @@ -12,6 +12,9 @@ { "path": "../opentelemetry-api" }, + { + "path": "../opentelemetry-api-metrics" + }, { "path": "../opentelemetry-context-async-hooks" }, diff --git a/tsconfig.json b/tsconfig.json index e772bb4c729..705bf6a93aa 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -11,6 +11,9 @@ { "path": "backwards-compatability/node8" }, + { + "path": "packages/opentelemetry-api-metrics" + }, { "path": "packages/opentelemetry-api" },