From 460d986f6739d5b89993987f98a39d16a19ea8b4 Mon Sep 17 00:00:00 2001 From: Daniel Dyla Date: Mon, 11 Nov 2019 17:02:55 -0500 Subject: [PATCH] feat: Add prometheus exporter (#483) * fix(http-plugin): move node-sdk to dev deps * feat: update dependencies * feat: server implementation and tests * fix: remove console logger * fix: add types * feat(prometheus-exporter): counter and gauge * feat(prometheus-exporter): implement counter and gauge * feat(prometheus-exporter): export configuration interface * fix: linting * fix: typo Co-Authored-By: Mayur Kale * chore: document ExporterConfig * fix: dependencies * fix: typo Co-Authored-By: Mayur Kale * chore: document sanitize method and make behavior more strict * chore: do not use global prom-client registry * chore: add defaults to description and metric endpoint * test: export couter, gauge, multiple, and none * test: sanitize prom metric names * fix: typo Co-Authored-By: Mayur Kale * chore: make _server read only * test: add tests for prom export configuration * style: make comments descriptive * test: update tests for label sets * fix: lint --- .../package.json | 9 +- .../src/export/types.ts | 53 ++ .../src/index.ts | 3 +- .../src/prometheus.ts | 309 ++++++++++++ .../test/prometheus.test.ts | 464 ++++++++++++++++++ .../tslint.json | 4 + 6 files changed, 838 insertions(+), 4 deletions(-) create mode 100644 packages/opentelemetry-exporter-prometheus/src/export/types.ts create mode 100644 packages/opentelemetry-exporter-prometheus/src/prometheus.ts create mode 100644 packages/opentelemetry-exporter-prometheus/test/prometheus.test.ts create mode 100644 packages/opentelemetry-exporter-prometheus/tslint.json diff --git a/packages/opentelemetry-exporter-prometheus/package.json b/packages/opentelemetry-exporter-prometheus/package.json index 990828e5f2..4361f1bf51 100644 --- a/packages/opentelemetry-exporter-prometheus/package.json +++ b/packages/opentelemetry-exporter-prometheus/package.json @@ -1,7 +1,6 @@ { "name": "@opentelemetry/exporter-prometheus", "version": "0.2.0", - "private": true, "description": "OpenTelemetry Exporter Prometheus provides a metrics endpoint for Prometheus", "main": "build/src/index.js", "types": "build/src/index.d.ts", @@ -43,16 +42,20 @@ "@types/node": "^12.6.9", "codecov": "^3.5.0", "gts": "^1.1.0", - "mocha": "^6.2.0", + "mocha": "^6.2.2", "nyc": "^14.1.1", "rimraf": "^3.0.0", "ts-mocha": "^6.0.0", "ts-node": "^8.3.0", + "tslint-consistent-codestyle": "^1.16.0", "tslint-microsoft-contrib": "^6.2.0", "typescript": "3.7.2" }, "dependencies": { + "@opentelemetry/base": "^0.2.0", "@opentelemetry/core": "^0.2.0", - "@opentelemetry/types": "^0.2.0" + "@opentelemetry/metrics": "^0.2.0", + "@opentelemetry/types": "^0.2.0", + "prom-client": "^11.5.3" } } diff --git a/packages/opentelemetry-exporter-prometheus/src/export/types.ts b/packages/opentelemetry-exporter-prometheus/src/export/types.ts new file mode 100644 index 0000000000..69ac40cb13 --- /dev/null +++ b/packages/opentelemetry-exporter-prometheus/src/export/types.ts @@ -0,0 +1,53 @@ +/*! + * Copyright 2019, 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 types from '@opentelemetry/types'; + +/** + * Configuration interface for prometheus exporter + */ +export interface ExporterConfig { + /** + * App prefix for metrics, if needed + * + * @default '' + * */ + prefix?: string; + + /** + * Endpoint the metrics should be exposed at with preceeding slash + * @default '/metrics' + */ + endpoint?: string; + + /** + * Port number for Prometheus exporter server + * + * Default registered port is 9464: + * https://github.com/prometheus/prometheus/wiki/Default-port-allocations + * @default 9464 + */ + port?: number; + + /** + * Define if the Prometheus exporter server will be started + * @default false + */ + startServer?: boolean; + + /** Standard logging interface */ + logger?: types.Logger; +} diff --git a/packages/opentelemetry-exporter-prometheus/src/index.ts b/packages/opentelemetry-exporter-prometheus/src/index.ts index ab4fd7cc33..ff3d57cb44 100644 --- a/packages/opentelemetry-exporter-prometheus/src/index.ts +++ b/packages/opentelemetry-exporter-prometheus/src/index.ts @@ -14,4 +14,5 @@ * limitations under the License. */ -// +export * from './prometheus'; +export * from './export/types'; diff --git a/packages/opentelemetry-exporter-prometheus/src/prometheus.ts b/packages/opentelemetry-exporter-prometheus/src/prometheus.ts new file mode 100644 index 0000000000..69f4545909 --- /dev/null +++ b/packages/opentelemetry-exporter-prometheus/src/prometheus.ts @@ -0,0 +1,309 @@ +/*! + * Copyright 2019, 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 { ExportResult } from '@opentelemetry/base'; +import { NoopLogger } from '@opentelemetry/core'; +import { + LabelValue, + MetricDescriptor, + MetricDescriptorType, + MetricExporter, + ReadableMetric, +} from '@opentelemetry/metrics'; +import * as types from '@opentelemetry/types'; +import { createServer, IncomingMessage, Server, ServerResponse } from 'http'; +import { Counter, Gauge, labelValues, Metric, Registry } from 'prom-client'; +import * as url from 'url'; +import { ExporterConfig } from './export/types'; + +export class PrometheusExporter implements MetricExporter { + static readonly DEFAULT_OPTIONS = { + port: 9464, + startServer: false, + endpoint: '/metrics', + prefix: '', + }; + + private readonly _registry = new Registry(); + private readonly _logger: types.Logger; + private readonly _port: number; + private readonly _endpoint: string; + private readonly _server: Server; + private readonly _prefix?: string; + private readonly _invalidCharacterRegex = /[^a-z0-9_]/gi; + + // This will be required when histogram is implemented. Leaving here so it is not forgotten + // Histogram cannot have a label named 'le' + // private static readonly RESERVED_HISTOGRAM_LABEL = 'le'; + + /** + * Constructor + * @param config Exporter configuration + * @param callback Callback to be called after a server was started + */ + constructor(config: ExporterConfig = {}, callback?: () => void) { + this._logger = config.logger || new NoopLogger(); + this._port = config.port || PrometheusExporter.DEFAULT_OPTIONS.port; + this._prefix = config.prefix || PrometheusExporter.DEFAULT_OPTIONS.prefix; + this._server = createServer(this._requestHandler); + + this._endpoint = ( + config.endpoint || PrometheusExporter.DEFAULT_OPTIONS.endpoint + ).replace(/^([^/])/, '/$1'); + + if (config.startServer || PrometheusExporter.DEFAULT_OPTIONS.startServer) { + this.startServer(callback); + } else if (callback) { + callback(); + } + } + + /** + * Saves the current values of all exported {@link ReadableMetric}s so that they can be pulled + * by the Prometheus backend. + * + * @todo reach into metrics to pull metric values on endpoint + * In its current state, the exporter saves the current values of all metrics when export + * is called and returns them when the export endpoint is called. In the future, this should + * be a no-op and the exporter should reach into the metrics when the export endpoint is + * called. As there is currently no interface to do this, this is our only option. + * + * @param readableMetrics Metrics to be sent to the prometheus backend + * @param cb result callback to be called on finish + */ + export( + readableMetrics: ReadableMetric[], + cb: (result: ExportResult) => void + ) { + if (!this._server) { + // It is conceivable that the _server may not be started as it is an async startup + // However unlikely, if this happens the caller may retry the export + cb(ExportResult.FAILED_RETRYABLE); + return; + } + + this._logger.debug('Prometheus exporter export'); + + for (const readableMetric of readableMetrics) { + this._updateMetric(readableMetric); + } + + cb(ExportResult.SUCCESS); + } + + /** + * Shuts down the export server and clears the registry + * + * @param cb called when server is stopped + */ + shutdown(cb?: () => void) { + this._registry.clear(); + this.stopServer(cb); + } + + /** + * Updates the value of a single metric in the registry + * + * @param readableMetric Metric value to be saved + */ + private _updateMetric(readableMetric: ReadableMetric) { + const metric = this._registerMetric(readableMetric); + if (!metric) return; + + const labelKeys = readableMetric.descriptor.labelKeys; + + if (metric instanceof Counter) { + for (const ts of readableMetric.timeseries) { + // Prometheus counter saves internal state and increments by given value. + // ReadableMetric value is the current state, not the delta to be incremented by. + // Currently, _registerMetric creates a new counter every time the value changes, + // so the increment here behaves as a set value (increment from 0) + metric.inc( + this._getLabelValues(labelKeys, ts.labelValues), + ts.points[0].value as number + ); + } + } + + if (metric instanceof Gauge) { + for (const ts of readableMetric.timeseries) { + metric.set( + this._getLabelValues(labelKeys, ts.labelValues), + ts.points[0].value as number + ); + } + } + + // TODO: only counter and gauge are implemented in metrics so far + } + + private _getLabelValues(keys: string[], values: LabelValue[]) { + const labelValues: labelValues = {}; + for (let i = 0; i < keys.length; i++) { + if (values[i].value !== null) { + labelValues[keys[i]] = values[i].value!; + } + } + return labelValues; + } + + private _registerMetric(readableMetric: ReadableMetric): Metric | undefined { + const metricName = this._getPrometheusMetricName(readableMetric.descriptor); + const metric = this._registry.getSingleMetric(metricName); + + /** + * Prometheus library does aggregation, which means its inc method must be called with + * the value to be incremented by. It does not have a set method. As our ReadableMetric + * contains the current value, not the value to be incremented by, we destroy and + * recreate counters when they are updated. + * + * This works because counters are identified by their name and no other internal ID + * https://prometheus.io/docs/instrumenting/exposition_formats/ + */ + if (metric instanceof Counter) { + this._registry.removeSingleMetric(metricName); + } else if (metric) return metric; + + return this._newMetric(readableMetric, metricName); + } + + private _newMetric( + readableMetric: ReadableMetric, + name: string + ): Metric | undefined { + const metricObject = { + name, + // prom-client throws with empty description which is our default + help: readableMetric.descriptor.description || 'description missing', + labelNames: readableMetric.descriptor.labelKeys, + // list of registries to register the newly created metric + registers: [this._registry], + }; + + switch (readableMetric.descriptor.type) { + case MetricDescriptorType.COUNTER_DOUBLE: + case MetricDescriptorType.COUNTER_INT64: + return new Counter(metricObject); + case MetricDescriptorType.GAUGE_DOUBLE: + case MetricDescriptorType.GAUGE_INT64: + return new Gauge(metricObject); + default: + // Other metric types are currently unimplemented + return undefined; + } + } + + private _getPrometheusMetricName(descriptor: MetricDescriptor): string { + return this._sanitizePrometheusMetricName( + this._prefix ? `${this._prefix}_${descriptor.name}` : descriptor.name + ); + } + + /** + * Ensures metric names are valid Prometheus metric names by removing + * characters allowed by OpenTelemetry but disallowed by Prometheus. + * + * https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels + * + * 1. Names must match `[a-zA-Z_:][a-zA-Z0-9_:]*` + * + * 2. Colons are reserved for user defined recording rules. + * They should not be used by exporters or direct instrumentation. + * + * OpenTelemetry metric names are already validated in the Meter when they are created, + * and they match the format `[a-zA-Z][a-zA-Z0-9_.\-]*` which is very close to a valid + * prometheus metric name, so we only need to strip characters valid in OpenTelemetry + * but not valid in prometheus and replace them with '_'. + * + * @param name name to be sanitized + */ + private _sanitizePrometheusMetricName(name: string): string { + return name.replace(this._invalidCharacterRegex, '_'); // replace all invalid characters with '_' + } + + /** + * Stops the Prometheus export server + * @param callback A callback that will be executed once the server is stopped + */ + stopServer(callback?: () => void) { + if (!this._server) { + this._logger.debug( + `Prometheus stopServer() was called but server was never started.` + ); + if (callback) { + callback(); + } + } else { + this._server.close(() => { + this._logger.debug(`Prometheus exporter was stopped`); + if (callback) { + callback(); + } + }); + } + } + + /** + * Starts the Prometheus export server + * + * @param callback called once the server is ready + */ + startServer(callback?: () => void) { + this._server.listen(this._port, () => { + this._logger.debug( + `Prometheus exporter started on port ${this._port} at endpoint ${this._endpoint}` + ); + if (callback) { + callback(); + } + }); + } + + /** + * Request handler used by http library to respond to incoming requests + * for the current state of metrics by the Prometheus backend. + * + * @param request Incoming HTTP request to export server + * @param response HTTP response object used to respond to request + */ + private _requestHandler = ( + request: IncomingMessage, + response: ServerResponse + ) => { + if (url.parse(request.url!).pathname === this._endpoint) { + this._exportMetrics(response); + } else { + this._notFound(response); + } + }; + + /** + * Responds to incoming message with current state of all metrics. + */ + private _exportMetrics = (response: ServerResponse) => { + response.statusCode = 200; + response.setHeader('content-type', this._registry.contentType); + response.end(this._registry.metrics() || '# no registered metrics'); + }; + + /** + * Responds with 404 status code to all requests that do not match the configured endpoint. + */ + private _notFound = (response: ServerResponse) => { + response.statusCode = 404; + response.end(); + }; +} diff --git a/packages/opentelemetry-exporter-prometheus/test/prometheus.test.ts b/packages/opentelemetry-exporter-prometheus/test/prometheus.test.ts new file mode 100644 index 0000000000..984a5feb4e --- /dev/null +++ b/packages/opentelemetry-exporter-prometheus/test/prometheus.test.ts @@ -0,0 +1,464 @@ +/*! + * Copyright 2019, 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 { CounterMetric, GaugeMetric, Meter } from '@opentelemetry/metrics'; +import * as assert from 'assert'; +import * as http from 'http'; +import { PrometheusExporter } from '../src'; + +describe('PrometheusExporter', () => { + describe('constructor', () => { + it('should construct an exporter', () => { + const exporter = new PrometheusExporter(); + assert.ok(typeof exporter.startServer === 'function'); + assert.ok(typeof exporter.shutdown === 'function'); + }); + + it('should start the server if startServer is passed as an option', done => { + const port = PrometheusExporter.DEFAULT_OPTIONS.port; + const endpoint = PrometheusExporter.DEFAULT_OPTIONS.endpoint; + const exporter = new PrometheusExporter( + { + startServer: true, + }, + () => { + const url = `http://localhost:${port}${endpoint}`; + http.get(url, function(res: any) { + assert.equal(res.statusCode, 200); + exporter.shutdown(() => { + return done(); + }); + }); + } + ); + }); + + it('should not start the server by default', () => { + const exporter = new PrometheusExporter(); + assert.ok(exporter['_server']!.listening === false); + }); + }); + + describe('server', () => { + it('it should start on startServer() and call the callback', done => { + const exporter = new PrometheusExporter({ + port: 9722, + }); + exporter.startServer(() => { + exporter.shutdown(() => { + return done(); + }); + }); + }); + + it('it should listen on the default port and default endpoint', done => { + const port = PrometheusExporter.DEFAULT_OPTIONS.port; + const endpoint = PrometheusExporter.DEFAULT_OPTIONS.endpoint; + const exporter = new PrometheusExporter(); + + exporter.startServer(() => { + const url = `http://localhost:${port}${endpoint}`; + http.get(url, function(res: any) { + assert.equal(res.statusCode, 200); + exporter.shutdown(() => { + return done(); + }); + }); + }); + }); + + it('it should listen on a custom port and endpoint if provided', done => { + const port = 9991; + const endpoint = '/metric'; + + const exporter = new PrometheusExporter({ + port, + endpoint, + }); + + exporter.startServer(() => { + const url = `http://localhost:${port}${endpoint}`; + http.get(url, function(res: any) { + assert.equal(res.statusCode, 200); + exporter.shutdown(() => { + return done(); + }); + }); + }); + }); + + it('it should not require endpoints to start with a slash', done => { + const port = 9991; + const endpoint = 'metric'; + + const exporter = new PrometheusExporter({ + port, + endpoint, + }); + + exporter.startServer(() => { + const url = `http://localhost:${port}/metric`; + http.get(url, function(res: any) { + assert.equal(res.statusCode, 200); + exporter.shutdown(() => { + const exporter2 = new PrometheusExporter({ + port, + endpoint: `/${endpoint}`, + }); + + exporter2.startServer(() => { + const url = `http://localhost:${port}/metric`; + http.get(url, function(res: any) { + assert.equal(res.statusCode, 200); + exporter2.stopServer(() => { + return done(); + }); + }); + }); + }); + }); + }); + }); + + it('it should return a HTTP status 404 if the endpoint does not match', done => { + const port = 9912; + const endpoint = '/metrics'; + const exporter = new PrometheusExporter({ + port, + endpoint, + }); + exporter.startServer(() => { + const url = `http://localhost:${port}/invalid`; + + http.get(url, function(res: any) { + assert.equal(res.statusCode, 404); + exporter.shutdown(() => { + return done(); + }); + }); + }); + }); + + it('should call a provided callback regardless of if the server is running', done => { + const exporter = new PrometheusExporter(); + exporter.shutdown(() => { + return done(); + }); + }); + }); + + describe('export', () => { + let exporter: PrometheusExporter; + let meter: Meter; + + beforeEach(done => { + exporter = new PrometheusExporter(); + meter = new Meter(); + exporter.startServer(done); + }); + + afterEach(done => { + exporter.shutdown(done); + }); + + it('should export a count aggregation', done => { + const counter = meter.createCounter('counter', { + description: 'a test description', + labelKeys: ['key1'], + }) as CounterMetric; + + const handle = counter.getHandle(meter.labels({ key1: 'labelValue1' })); + handle.add(10); + exporter.export(meter.getMetrics(), () => { + // This is to test the special case where counters are destroyed + // and recreated in the exporter in order to get around prom-client's + // aggregation and use ours. + handle.add(10); + exporter.export(meter.getMetrics(), () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.strictEqual( + lines[0], + '# HELP counter a test description' + ); + + assert.deepEqual(lines, [ + '# HELP counter a test description', + '# TYPE counter counter', + 'counter{key1="labelValue1"} 20', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + }); + + it('should export a gauge aggregation', done => { + const gauge = meter.createGauge('gauge', { + description: 'a test description', + labelKeys: ['key1'], + }) as GaugeMetric; + + const handle = gauge.getHandle(meter.labels({ key1: 'labelValue1' })); + handle.set(10); + exporter.export([gauge.get()!], () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge a test description', + '# TYPE gauge gauge', + 'gauge{key1="labelValue1"} 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + + it('should export a multiple aggregations', done => { + const gauge = meter.createGauge('gauge', { + description: 'a test description', + labelKeys: ['gaugeKey1'], + }) as GaugeMetric; + + const counter = meter.createCounter('counter', { + description: 'a test description', + labelKeys: ['counterKey1'], + }) as CounterMetric; + + gauge.getHandle(meter.labels({ key1: 'labelValue1' })).set(10); + counter.getHandle(meter.labels({ key1: 'labelValue1' })).add(10); + exporter.export([gauge.get()!, counter.get()!], () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge a test description', + '# TYPE gauge gauge', + 'gauge{gaugeKey1="labelValue1"} 10', + '', + '# HELP counter a test description', + '# TYPE counter counter', + 'counter{counterKey1="labelValue1"} 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + + it('should export a comment if no metrics are registered', done => { + exporter.export([], () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, ['# no registered metrics']); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + + it('should add a description if missing', done => { + const gauge = meter.createGauge('gauge') as GaugeMetric; + + const handle = gauge.getHandle(meter.labels({ key1: 'labelValue1' })); + handle.set(10); + exporter.export([gauge.get()!], () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge description missing', + '# TYPE gauge gauge', + 'gauge 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + + it('should sanitize names', done => { + const gauge = meter.createGauge('gauge.bad-name') as GaugeMetric; + const handle = gauge.getHandle(meter.labels({ key1: 'labelValue1' })); + handle.set(10); + exporter.export([gauge.get()!], () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge_bad_name description missing', + '# TYPE gauge_bad_name gauge', + 'gauge_bad_name 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + }); + + describe('configuration', () => { + let meter: Meter; + let gauge: GaugeMetric; + let exporter: PrometheusExporter | undefined; + + beforeEach(() => { + meter = new Meter(); + gauge = meter.createGauge('gauge') as GaugeMetric; + gauge.getHandle(meter.labels({ key1: 'labelValue1' })).set(10); + }); + + afterEach(done => { + if (exporter) { + exporter.shutdown(done); + exporter = undefined; + } else { + done(); + } + }); + + it('should use a configured name prefix', done => { + exporter = new PrometheusExporter({ + prefix: 'test_prefix', + }); + + exporter.startServer(() => { + exporter!.export(meter.getMetrics(), () => { + http + .get('http://localhost:9464/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP test_prefix_gauge description missing', + '# TYPE test_prefix_gauge gauge', + 'test_prefix_gauge 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + }); + + it('should use a configured port', done => { + exporter = new PrometheusExporter({ + port: 8080, + }); + + exporter.startServer(() => { + exporter!.export(meter.getMetrics(), () => { + http + .get('http://localhost:8080/metrics', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge description missing', + '# TYPE gauge gauge', + 'gauge 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + }); + + it('should use a configured endpoint', done => { + exporter = new PrometheusExporter({ + endpoint: '/test', + }); + + exporter.startServer(() => { + exporter!.export(meter.getMetrics(), () => { + http + .get('http://localhost:9464/test', res => { + res.on('data', chunk => { + const body = chunk.toString(); + const lines = body.split('\n'); + + assert.deepEqual(lines, [ + '# HELP gauge description missing', + '# TYPE gauge gauge', + 'gauge 10', + '', + ]); + + done(); + }); + }) + .on('error', errorHandler(done)); + }); + }); + }); + }); +}); + +function errorHandler(done: Mocha.Done): (err: Error) => void { + return () => { + assert.ok(false, 'error getting metrics'); + done(); + }; +} diff --git a/packages/opentelemetry-exporter-prometheus/tslint.json b/packages/opentelemetry-exporter-prometheus/tslint.json new file mode 100644 index 0000000000..0710b135d0 --- /dev/null +++ b/packages/opentelemetry-exporter-prometheus/tslint.json @@ -0,0 +1,4 @@ +{ + "rulesDirectory": ["node_modules/tslint-microsoft-contrib"], + "extends": ["../../tslint.base.js", "./node_modules/tslint-consistent-codestyle"] +}