6990662449

Committed 25 Nov 2023 06:13PM UTC coverage: 94.162% (-0.001%) from 94.163%

Build # 6990662449

Build Type

push

github

Committed by

icebob

Commit Message

fix lint

Run Details

5314 of 5865 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

5 existing lines in 3 files now uncovered.

7202 of 7427 relevant lines covered (96.97%)

1497.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.72

/src/metrics/reporters/datadog.js

/*
 * moleculer
 * Copyright (c) 2019 MoleculerJS (https://github.com/moleculerjs/moleculer)
 * MIT Licensed
 */

"use strict";

const BaseReporter = require("./base");
const _ = require("lodash");
const os = require("os");
const { MoleculerError } = require("../../errors");
const METRIC = require("../constants");
const { isFunction } = require("../../utils");

const BASE_URL = "https://api.datadoghq.com/api/";

/**
 * Datadog reporter for Moleculer.
 *
 *                 https://www.datadoghq.com/
 *
 */
class DatadogReporter extends BaseReporter {
        /**
         * Constructor of DatadogReporters
         * @param {Object} opts
         * @memberof DatadogReporter
         */
        constructor(opts) {
                super(opts);

                this.opts = _.defaultsDeep(this.opts, {
                        host: os.hostname(),
                        baseUrl: BASE_URL,
                        apiVersion: "v1",
                        path: "/series",
                        apiKey: process.env.DATADOG_API_KEY,
                        //appKey: process.env.DATADOG_APP_KEY,
                        defaultLabels: registry => ({
                                namespace: registry.broker.namespace,
                                nodeID: registry.broker.nodeID
                        }),
                        interval: 10
                });

                if (!this.opts.apiKey)
                        throw new MoleculerError(
                                "Datadog API key is missing. Set DATADOG_API_KEY environment variable."
                        );
        }

        /**
         * Initialize reporter.
         *
         * @param {MetricRegistry} registry
         * @memberof DatadogReporter
         */
        init(registry) {
                super.init(registry);

                if (this.opts.interval > 0) {
                        this.timer = setInterval(() => this.flush(), this.opts.interval * 1000);
                        this.timer.unref();
                }

                this.defaultLabels = isFunction(this.opts.defaultLabels)
                        ? this.opts.defaultLabels.call(this, registry)
                        : this.opts.defaultLabels;
        }

        /**
         * Stop reporter
         *
         * @memberof DatadogReporter
         */
        stop() {
                if (this.timer) {
                        clearInterval(this.timer);
                        this.timer = null;
                }
                return Promise.resolve();
        }

        /**
         * Flush metric data to Datadog server
         *
         * @memberof DatadogReporter
         */
        flush() {
                const series = this.generateDatadogSeries();

                if (series.length === 0) return;

                return fetch(
                        `${this.opts.baseUrl}${this.opts.apiVersion}${this.opts.path}?api_key=${this.opts.apiKey}`,
                        {
                                method: "post",
                                body: JSON.stringify({ series }),
                                headers: {
                                        "Content-Type": "application/json"
                                }
                        }
                )
                        .then(res => {
                                this.logger.debug("Metrics are uploaded to DataDog. Status: ", res.statusText);
                        })
                        .catch(err => {
                                /* istanbul ignore next */
                                this.logger.warn(
                                        "Unable to upload metrics to Datadog server. Error:" + err.message,
                                        err
                                );
                        });
        }

        /**
         * Generate Datadog metric data.
         * @returns {Array<Object>}
         *
         * @memberof DatadogReporter
         */
        generateDatadogSeries() {
                const series = [];

                const now = this.posixTimestamp(Date.now());

                this.registry.store.forEach(metric => {
                        // Filtering
                        if (!this.matchMetricName(metric.name)) return;
                        // Skip datetime metrics (register too much labels)
                        if (metric.name.startsWith("os.datetime")) return;

                        /* More info: https://docs.datadoghq.com/api/?lang=bash#post-timeseries-points

                                metric [required]:
                                        The name of the timeseries
                                type [optional, default=gauge]:
                                        Type of your metric either: gauge, rate, or count
                                interval [optional, default=None]:
                                        If the type of the metric is rate or count, define the corresponding interval.
                                points [required]:
                                        A JSON array of points. Each point is of the form:
                                        [[POSIX_timestamp, numeric_value], ...]
                                        Note: The timestamp should be in seconds, current, and its format should be a 32bit float gauge-type value. Current is defined as not more than 10 minutes in the future or more than 1 hour in the past.
                                host [optional]:
                                        The name of the host that produced the metric.
                                tags [optional, default=None]:
                                        A list of tags associated with the metric.
                        */

                        const snapshot = metric.snapshot();
                        if (snapshot.length === 0) return;

                        switch (metric.type) {
                                case METRIC.TYPE_COUNTER:
                                case METRIC.TYPE_GAUGE: {
                                        snapshot.forEach(item => {
                                                series.push({
                                                        metric: this.formatMetricName(metric.name),
                                                        type: "gauge",
                                                        points: [[now, item.value]],
                                                        tags: this.labelsToTags(item.labels),
                                                        host: this.opts.host
                                                });
                                        });

                                        break;
                                }
                                /*case METRIC.TYPE_INFO: {
                                        series.push(`# HELP ${metricName} ${metricDesc}`);
                                        series.push(`# TYPE ${metricName} gauge`);
                                        snapshot.forEach(item => {
                                                const labelStr = this.labelsToStr(item.labels, { value: item.value });
                                                series.push(`${metricName}${labelStr} 1`);
                                        });
                                        series.push("");

                                        break;
                                }*/
                                case METRIC.TYPE_HISTOGRAM: {
                                        snapshot.forEach(item => {
                                                if (item.buckets) {
                                                        Object.keys(item.buckets).forEach(le => {
                                                                series.push({
                                                                        metric: this.formatMetricName(metric.name + ".bucket_" + le),
                                                                        type: "rate",
                                                                        points: [[now, item.buckets[le]]],
                                                                        tags: this.labelsToTags(item.labels),
                                                                        host: this.opts.host
                                                                });
                                                        });
                                                        // +Inf
                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".bucket_inf"),
                                                                type: "rate",
                                                                points: [[now, item.count]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });
                                                }

                                                if (item.quantiles) {
                                                        Object.keys(item.quantiles).forEach(key => {
                                                                series.push({
                                                                        metric: this.formatMetricName(metric.name + ".q" + key),
                                                                        type: "rate",
                                                                        points: [[now, item.quantiles[key]]],
                                                                        tags: this.labelsToTags(item.labels),
                                                                        host: this.opts.host
                                                                });
                                                        });

                                                        // Add other calculated values
                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".sum"),
                                                                type: "rate",
                                                                points: [[now, item.sum]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".count"),
                                                                type: "rate",
                                                                points: [[now, item.count]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".min"),
                                                                type: "rate",
                                                                points: [[now, item.min]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".mean"),
                                                                type: "rate",
                                                                points: [[now, item.mean]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".variance"),
                                                                type: "rate",
                                                                points: [[now, item.variance]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".stddev"),
                                                                type: "rate",
                                                                points: [[now, item.stdDev]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });

                                                        series.push({
                                                                metric: this.formatMetricName(metric.name + ".max"),
                                                                type: "rate",
                                                                points: [[now, item.max]],
                                                                tags: this.labelsToTags(item.labels),
                                                                host: this.opts.host
                                                        });
                                                }
                                        });
                                        break;
                                }
                        }
                });

                return series;
        }

        /**
         * Escape label value characters.
         * @param {String} str
         * @returns {String}
         * @memberof DatadogReporter
         */
        escapeLabelValue(str) {
                if (typeof str == "string") return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
                return str;
        }

        /**
         * Convert labels to Prometheus label string
         *
         * @param {Object} itemLabels
         * @returns {Array<String>}
         *
         * @memberof DatadogReporter
         */
        labelsToTags(itemLabels) {
                const labels = Object.assign({}, this.defaultLabels || {}, itemLabels || {});
                const keys = Object.keys(labels);
                if (keys.length === 0) return [];

                return keys.map(
                        key => `${this.formatLabelName(key)}:${this.escapeLabelValue(labels[key])}`
                );
        }

        posixTimestamp(time) {
                return time != null ? Math.floor(time / 1000) : undefined;
        }
}

module.exports = DatadogReporter;

1	/*
2	* moleculer
3	* Copyright (c) 2019 MoleculerJS (https://github.com/moleculerjs/moleculer)
4	* MIT Licensed
5	*/
6
7	"use strict";
8
9	const BaseReporter = require("./base");	624✔
10	const _ = require("lodash");	624✔
11	const os = require("os");	624✔
12	const { MoleculerError } = require("../../errors");	624✔
13	const METRIC = require("../constants");	624✔
14	const { isFunction } = require("../../utils");	624✔
15
16	const BASE_URL = "https://api.datadoghq.com/api/";	624✔
17
18	/**
19	* Datadog reporter for Moleculer.
20	*
21	* https://www.datadoghq.com/
22	*
23	*/
24	class DatadogReporter extends BaseReporter {
25	/**
26	* Constructor of DatadogReporters
27	* @param {Object} opts
28	* @memberof DatadogReporter
29	*/
30	constructor(opts) {
31	super(opts);	66✔
32
33	this.opts = _.defaultsDeep(this.opts, {	66✔
34	host: os.hostname(),
35	baseUrl: BASE_URL,
36	apiVersion: "v1",
37	path: "/series",
38	apiKey: process.env.DATADOG_API_KEY,
39	//appKey: process.env.DATADOG_APP_KEY,
40	defaultLabels: registry => ({	24✔
41	namespace: registry.broker.namespace,
42	nodeID: registry.broker.nodeID
43	}),
44	interval: 10
45	});
46
47	if (!this.opts.apiKey)	66✔
48	throw new MoleculerError(	6✔
49	"Datadog API key is missing. Set DATADOG_API_KEY environment variable."
50	);
51	}
52
53	/**
54	* Initialize reporter.
55	*
56	* @param {MetricRegistry} registry
57	* @memberof DatadogReporter
58	*/
59	init(registry) {
60	super.init(registry);	36✔
61
62	if (this.opts.interval > 0) {	36!
63	this.timer = setInterval(() => this.flush(), this.opts.interval * 1000);	36✔
64	this.timer.unref();	36✔
65	}
66
67	this.defaultLabels = isFunction(this.opts.defaultLabels)	36✔
68	? this.opts.defaultLabels.call(this, registry)
69	: this.opts.defaultLabels;
70	}
71
72	/**
73	* Stop reporter
74	*
75	* @memberof DatadogReporter
76	*/
77	stop() {
78	if (this.timer) {	36!
79	clearInterval(this.timer);	36✔
80	this.timer = null;	36✔
81	}
82	return Promise.resolve();	36✔
83	}
84
85	/**
86	* Flush metric data to Datadog server
87	*
88	* @memberof DatadogReporter
89	*/
90	flush() {
91	const series = this.generateDatadogSeries();	12✔
92
93	if (series.length === 0) return;	12✔
94
95	return fetch(	6✔
96	`${this.opts.baseUrl}${this.opts.apiVersion}${this.opts.path}?api_key=${this.opts.apiKey}`,
97	{
98	method: "post",
99	body: JSON.stringify({ series }),
100	headers: {
101	"Content-Type": "application/json"
102	}
103	}
104	)
105	.then(res => {
106	this.logger.debug("Metrics are uploaded to DataDog. Status: ", res.statusText);	6✔
107	})
108	.catch(err => {
109	/* istanbul ignore next */
110	this.logger.warn(
111	"Unable to upload metrics to Datadog server. Error:" + err.message,
112	err
113	);
114	});
115	}
116
117	/**
118	* Generate Datadog metric data.
119	* @returns {Array<Object>}
120	*
121	* @memberof DatadogReporter
122	*/
123	generateDatadogSeries() {
124	const series = [];	6✔
125
126	const now = this.posixTimestamp(Date.now());	6✔
127
128	this.registry.store.forEach(metric => {	6✔
129	// Filtering
130	if (!this.matchMetricName(metric.name)) return;	30!
131	// Skip datetime metrics (register too much labels)
132	if (metric.name.startsWith("os.datetime")) return;	30✔
133
134	/* More info: https://docs.datadoghq.com/api/?lang=bash#post-timeseries-points
135
136	metric [required]:
137	The name of the timeseries
138	type [optional, default=gauge]:
139	Type of your metric either: gauge, rate, or count
140	interval [optional, default=None]:
141	If the type of the metric is rate or count, define the corresponding interval.
142	points [required]:
143	A JSON array of points. Each point is of the form:
144	[[POSIX_timestamp, numeric_value], ...]
145	Note: The timestamp should be in seconds, current, and its format should be a 32bit float gauge-type value. Current is defined as not more than 10 minutes in the future or more than 1 hour in the past.
146	host [optional]:
147	The name of the host that produced the metric.
148	tags [optional, default=None]:
149	A list of tags associated with the metric.
150	*/
151
152	const snapshot = metric.snapshot();	24✔
153	if (snapshot.length === 0) return;	24!
154
155	switch (metric.type) {	24✔
156	case METRIC.TYPE_COUNTER:
157	case METRIC.TYPE_GAUGE: {
158	snapshot.forEach(item => {	12✔
159	series.push({	18✔
160	metric: this.formatMetricName(metric.name),
161	type: "gauge",
162	points: [[now, item.value]],
163	tags: this.labelsToTags(item.labels),
164	host: this.opts.host
165	});
166	});
167
168	break;	12✔
169	}
170	/*case METRIC.TYPE_INFO: {
171	series.push(`# HELP ${metricName} ${metricDesc}`);
172	series.push(`# TYPE ${metricName} gauge`);
173	snapshot.forEach(item => {
174	const labelStr = this.labelsToStr(item.labels, { value: item.value });
175	series.push(`${metricName}${labelStr} 1`);
176	});
177	series.push("");
178
179	break;
180	}*/
181	case METRIC.TYPE_HISTOGRAM: {
182	snapshot.forEach(item => {	6✔
183	if (item.buckets) {	12!
184	Object.keys(item.buckets).forEach(le => {	12✔
185	series.push({	144✔
186	metric: this.formatMetricName(metric.name + ".bucket_" + le),
187	type: "rate",
188	points: [[now, item.buckets[le]]],
189	tags: this.labelsToTags(item.labels),
190	host: this.opts.host
191	});
192	});
193	// +Inf
194	series.push({	12✔
195	metric: this.formatMetricName(metric.name + ".bucket_inf"),
196	type: "rate",
197	points: [[now, item.count]],
198	tags: this.labelsToTags(item.labels),
199	host: this.opts.host
200	});
201	}
202
203	if (item.quantiles) {	12!
204	Object.keys(item.quantiles).forEach(key => {	12✔
205	series.push({	60✔
206	metric: this.formatMetricName(metric.name + ".q" + key),
207	type: "rate",
208	points: [[now, item.quantiles[key]]],
209	tags: this.labelsToTags(item.labels),
210	host: this.opts.host
211	});
212	});
213
214	// Add other calculated values
215	series.push({	12✔
216	metric: this.formatMetricName(metric.name + ".sum"),
217	type: "rate",
218	points: [[now, item.sum]],
219	tags: this.labelsToTags(item.labels),
220	host: this.opts.host
221	});
222
223	series.push({	12✔
224	metric: this.formatMetricName(metric.name + ".count"),
225	type: "rate",
226	points: [[now, item.count]],
227	tags: this.labelsToTags(item.labels),
228	host: this.opts.host
229	});
230
231	series.push({	12✔
232	metric: this.formatMetricName(metric.name + ".min"),
233	type: "rate",
234	points: [[now, item.min]],
235	tags: this.labelsToTags(item.labels),
236	host: this.opts.host
237	});
238
239	series.push({	12✔
240	metric: this.formatMetricName(metric.name + ".mean"),
241	type: "rate",
242	points: [[now, item.mean]],
243	tags: this.labelsToTags(item.labels),
244	host: this.opts.host
245	});
246
247	series.push({	12✔
248	metric: this.formatMetricName(metric.name + ".variance"),
249	type: "rate",
250	points: [[now, item.variance]],
251	tags: this.labelsToTags(item.labels),
252	host: this.opts.host
253	});
254
255	series.push({	12✔
256	metric: this.formatMetricName(metric.name + ".stddev"),
257	type: "rate",
258	points: [[now, item.stdDev]],
259	tags: this.labelsToTags(item.labels),
260	host: this.opts.host
261	});
262
263	series.push({	12✔
264	metric: this.formatMetricName(metric.name + ".max"),
265	type: "rate",
266	points: [[now, item.max]],
267	tags: this.labelsToTags(item.labels),
268	host: this.opts.host
269	});
270	}
271	});
272	break;	6✔
273	}
274	}
275	});
276
277	return series;	6✔
278	}
279
280	/**
281	* Escape label value characters.
282	* @param {String} str
283	* @returns {String}
284	* @memberof DatadogReporter
285	*/
286	escapeLabelValue(str) {
287	if (typeof str == "string") return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');	480!
UNCOV 288	return str;	×
289	}
290
291	/**
292	* Convert labels to Prometheus label string
293	*
294	* @param {Object} itemLabels
295	* @returns {Array<String>}
296	*
297	* @memberof DatadogReporter
298	*/
299	labelsToTags(itemLabels) {
300	const labels = Object.assign({}, this.defaultLabels \|\| {}, itemLabels \|\| {});	318!
301	const keys = Object.keys(labels);	318✔
302	if (keys.length === 0) return [];	318✔
303
304	return keys.map(	318✔
305	key => `${this.formatLabelName(key)}:${this.escapeLabelValue(labels[key])}`	480✔
306	);
307	}
308
309	posixTimestamp(time) {
310	return time != null ? Math.floor(time / 1000) : undefined;	6!
311	}
312	}
313
314	module.exports = DatadogReporter;	624✔

moleculerjs / moleculer / 6990662449

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous