@watchtowerobservability/node 0.2.0 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +186 -3
- package/dist/cjs/appsec.d.ts +95 -0
- package/dist/cjs/appsec.js +206 -0
- package/dist/cjs/iast.d.ts +27 -0
- package/dist/cjs/iast.js +138 -0
- package/dist/cjs/index.d.ts +3 -0
- package/dist/cjs/index.js +14 -1
- package/dist/cjs/integrations/amqp.d.ts +13 -0
- package/dist/cjs/integrations/amqp.js +96 -0
- package/dist/cjs/integrations/bullmq.d.ts +19 -0
- package/dist/cjs/integrations/bullmq.js +83 -0
- package/dist/cjs/integrations/cache.d.ts +13 -0
- package/dist/cjs/integrations/cache.js +51 -0
- package/dist/cjs/integrations/db.d.ts +62 -0
- package/dist/cjs/integrations/db.js +288 -0
- package/dist/cjs/integrations/duckdb.d.ts +22 -0
- package/dist/cjs/integrations/duckdb.js +66 -0
- package/dist/cjs/integrations/graphile-worker.d.ts +22 -0
- package/dist/cjs/integrations/graphile-worker.js +50 -0
- package/dist/cjs/integrations/level.d.ts +18 -0
- package/dist/cjs/integrations/level.js +71 -0
- package/dist/cjs/integrations/lmdb.d.ts +26 -0
- package/dist/cjs/integrations/lmdb.js +78 -0
- package/dist/cjs/integrations/messaging.d.ts +17 -0
- package/dist/cjs/integrations/messaging.js +73 -0
- package/dist/cjs/integrations/mqtt.d.ts +7 -0
- package/dist/cjs/integrations/mqtt.js +41 -0
- package/dist/cjs/integrations/nats.d.ts +17 -0
- package/dist/cjs/integrations/nats.js +73 -0
- package/dist/cjs/integrations/orm.d.ts +47 -0
- package/dist/cjs/integrations/orm.js +93 -0
- package/dist/cjs/integrations/pg-boss.d.ts +8 -0
- package/dist/cjs/integrations/pg-boss.js +63 -0
- package/dist/cjs/integrations/pools.d.ts +41 -0
- package/dist/cjs/integrations/pools.js +94 -0
- package/dist/cjs/integrations/postgres.d.ts +12 -0
- package/dist/cjs/integrations/postgres.js +92 -0
- package/dist/cjs/integrations/sqlite.d.ts +36 -0
- package/dist/cjs/integrations/sqlite.js +125 -0
- package/dist/cjs/pprof.d.ts +6 -0
- package/dist/cjs/pprof.js +88 -0
- package/dist/cjs/profiling.d.ts +4 -1
- package/dist/cjs/profiling.js +18 -8
- package/dist/cjs/sql.d.ts +19 -0
- package/dist/cjs/sql.js +332 -0
- package/dist/cjs/test-plan.d.ts +10 -1
- package/dist/cjs/test-plan.js +91 -1
- package/dist/esm/appsec.d.ts +95 -0
- package/dist/esm/appsec.js +193 -0
- package/dist/esm/iast.d.ts +27 -0
- package/dist/esm/iast.js +130 -0
- package/dist/esm/index.d.ts +3 -0
- package/dist/esm/index.js +14 -1
- package/dist/esm/integrations/amqp.d.ts +13 -0
- package/dist/esm/integrations/amqp.js +92 -0
- package/dist/esm/integrations/bullmq.d.ts +19 -0
- package/dist/esm/integrations/bullmq.js +79 -0
- package/dist/esm/integrations/cache.d.ts +13 -0
- package/dist/esm/integrations/cache.js +46 -0
- package/dist/esm/integrations/db.d.ts +62 -0
- package/dist/esm/integrations/db.js +239 -0
- package/dist/esm/integrations/duckdb.d.ts +22 -0
- package/dist/esm/integrations/duckdb.js +29 -0
- package/dist/esm/integrations/graphile-worker.d.ts +22 -0
- package/dist/esm/integrations/graphile-worker.js +46 -0
- package/dist/esm/integrations/level.d.ts +18 -0
- package/dist/esm/integrations/level.js +35 -0
- package/dist/esm/integrations/lmdb.d.ts +26 -0
- package/dist/esm/integrations/lmdb.js +42 -0
- package/dist/esm/integrations/messaging.d.ts +17 -0
- package/dist/esm/integrations/messaging.js +64 -0
- package/dist/esm/integrations/mqtt.d.ts +7 -0
- package/dist/esm/integrations/mqtt.js +38 -0
- package/dist/esm/integrations/nats.d.ts +17 -0
- package/dist/esm/integrations/nats.js +70 -0
- package/dist/esm/integrations/orm.d.ts +47 -0
- package/dist/esm/integrations/orm.js +86 -0
- package/dist/esm/integrations/pg-boss.d.ts +8 -0
- package/dist/esm/integrations/pg-boss.js +60 -0
- package/dist/esm/integrations/pools.d.ts +41 -0
- package/dist/esm/integrations/pools.js +89 -0
- package/dist/esm/integrations/postgres.d.ts +12 -0
- package/dist/esm/integrations/postgres.js +55 -0
- package/dist/esm/integrations/sqlite.d.ts +36 -0
- package/dist/esm/integrations/sqlite.js +84 -0
- package/dist/esm/pprof.d.ts +6 -0
- package/dist/esm/pprof.js +85 -0
- package/dist/esm/profiling.d.ts +4 -1
- package/dist/esm/profiling.js +17 -8
- package/dist/esm/sql.d.ts +19 -0
- package/dist/esm/sql.js +324 -0
- package/dist/esm/test-plan.d.ts +10 -1
- package/dist/esm/test-plan.js +89 -1
- package/package.json +171 -1
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.CONTEXT_KEY = void 0;
|
|
4
|
+
exports.isPlainObject = isPlainObject;
|
|
5
|
+
exports.headers = headers;
|
|
6
|
+
exports.injectData = injectData;
|
|
7
|
+
exports.takeContext = takeContext;
|
|
8
|
+
exports.produce = produce;
|
|
9
|
+
exports.consume = consume;
|
|
10
|
+
// Shared core for queue and broker integrations: PRODUCER spans that hand out W3C headers, and
|
|
11
|
+
// CONSUMER spans parented by (and linked to) the producer, so the server can compute lag.
|
|
12
|
+
const api_1 = require("@opentelemetry/api");
|
|
13
|
+
const db_js_1 = require("./db.js");
|
|
14
|
+
/** Key in job data that carries the producer's trace context (W3C `traceparent`/`tracestate`). */
|
|
15
|
+
exports.CONTEXT_KEY = '_wt';
|
|
16
|
+
function isPlainObject(v) {
|
|
17
|
+
return typeof v === 'object' && v !== null && !Array.isArray(v);
|
|
18
|
+
}
|
|
19
|
+
/** The active context as W3C headers. */
|
|
20
|
+
function headers() {
|
|
21
|
+
const carrier = {};
|
|
22
|
+
api_1.propagation.inject(api_1.context.active(), carrier);
|
|
23
|
+
return carrier;
|
|
24
|
+
}
|
|
25
|
+
/** Copy of `data` carrying the active context under `_wt`; non-object data is returned unchanged. */
|
|
26
|
+
function injectData(data) {
|
|
27
|
+
if (data !== undefined && !isPlainObject(data))
|
|
28
|
+
return data;
|
|
29
|
+
const carrier = headers();
|
|
30
|
+
return Object.keys(carrier).length ? { ...data, [exports.CONTEXT_KEY]: carrier } : data;
|
|
31
|
+
}
|
|
32
|
+
/** Remove and return the `_wt` carrier from object job data. */
|
|
33
|
+
function takeContext(data) {
|
|
34
|
+
if (!isPlainObject(data) || !isPlainObject(data[exports.CONTEXT_KEY]))
|
|
35
|
+
return undefined;
|
|
36
|
+
const c = data[exports.CONTEXT_KEY];
|
|
37
|
+
delete data[exports.CONTEXT_KEY];
|
|
38
|
+
return c;
|
|
39
|
+
}
|
|
40
|
+
/** A PRODUCER span around `fn`, which gets the headers to send (the producer span's context). */
|
|
41
|
+
function produce(name, attributes, fn) {
|
|
42
|
+
const parent = api_1.context.active();
|
|
43
|
+
if ((0, db_js_1.inside)(parent))
|
|
44
|
+
return fn(headers());
|
|
45
|
+
const span = api_1.trace.getTracer('watchtower').startSpan(name, { kind: api_1.SpanKind.PRODUCER, attributes }, parent);
|
|
46
|
+
return (0, db_js_1.settle)(span, () => api_1.context.with((0, db_js_1.enter)(parent, span), () => fn(headers())));
|
|
47
|
+
}
|
|
48
|
+
const str = (v) => (typeof v === 'string' ? v : v instanceof Uint8Array ? Buffer.from(v).toString() : undefined);
|
|
49
|
+
/**
|
|
50
|
+
* A CONSUMER span around `fn`, linked to the producer context of each carrier (header maps whose
|
|
51
|
+
* values may be strings or Buffers). With exactly one carrier the producer span is also the parent.
|
|
52
|
+
*/
|
|
53
|
+
function consume(name, attributes, carriers, fn) {
|
|
54
|
+
let parent = api_1.context.active();
|
|
55
|
+
const links = [];
|
|
56
|
+
for (const c of carriers) {
|
|
57
|
+
if (!c)
|
|
58
|
+
continue;
|
|
59
|
+
const tp = str(c.traceparent);
|
|
60
|
+
if (!tp)
|
|
61
|
+
continue;
|
|
62
|
+
const ts = str(c.tracestate);
|
|
63
|
+
const ctx = api_1.propagation.extract(parent, { traceparent: tp, ...(ts ? { tracestate: ts } : {}) });
|
|
64
|
+
const sc = api_1.trace.getSpanContext(ctx);
|
|
65
|
+
if (!sc || !api_1.trace.isSpanContextValid(sc))
|
|
66
|
+
continue;
|
|
67
|
+
links.push({ context: sc });
|
|
68
|
+
if (carriers.length === 1)
|
|
69
|
+
parent = ctx;
|
|
70
|
+
}
|
|
71
|
+
const span = api_1.trace.getTracer('watchtower').startSpan(name, { kind: api_1.SpanKind.CONSUMER, attributes, links }, parent);
|
|
72
|
+
return (0, db_js_1.settle)(span, () => api_1.context.with((0, db_js_1.enter)(parent, span, false), fn));
|
|
73
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `instrumentMqtt(mqtt.connect(url))` for mqtt.js: PRODUCER spans on `publish`/`publishAsync`, and a
|
|
3
|
+
* CONSUMER span around the client's `message` listeners. The trace context travels in MQTT 5 user
|
|
4
|
+
* properties, so only `protocolVersion: 5` clients propagate (older clients get unlinked spans).
|
|
5
|
+
* shortcut: `publish` spans end when the call returns, not at the QoS 1/2 ack; use `publishAsync` for ack time.
|
|
6
|
+
*/
|
|
7
|
+
export declare function instrumentMqtt(client: object): void;
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.instrumentMqtt = instrumentMqtt;
|
|
4
|
+
const db_js_1 = require("./db.js");
|
|
5
|
+
const messaging_js_1 = require("./messaging.js");
|
|
6
|
+
const attrs = (topic, type, op, payload, id) => ({
|
|
7
|
+
'messaging.system': 'mqtt',
|
|
8
|
+
'messaging.destination.name': topic,
|
|
9
|
+
'messaging.operation.type': type,
|
|
10
|
+
'messaging.operation.name': op,
|
|
11
|
+
...(typeof payload === 'string' || payload instanceof Uint8Array ? { 'messaging.message.body.size': payload.length } : {}),
|
|
12
|
+
...(id !== undefined ? { 'messaging.message.id': String(id) } : {}),
|
|
13
|
+
});
|
|
14
|
+
/**
|
|
15
|
+
* `instrumentMqtt(mqtt.connect(url))` for mqtt.js: PRODUCER spans on `publish`/`publishAsync`, and a
|
|
16
|
+
* CONSUMER span around the client's `message` listeners. The trace context travels in MQTT 5 user
|
|
17
|
+
* properties, so only `protocolVersion: 5` clients propagate (older clients get unlinked spans).
|
|
18
|
+
* shortcut: `publish` spans end when the call returns, not at the QoS 1/2 ack; use `publishAsync` for ack time.
|
|
19
|
+
*/
|
|
20
|
+
function instrumentMqtt(client) {
|
|
21
|
+
const v5 = () => client.options?.protocolVersion === 5;
|
|
22
|
+
(0, db_js_1.patch)(client, 'publish', (orig) => function (topic, message, opts, cb) {
|
|
23
|
+
if (typeof opts === 'function')
|
|
24
|
+
[cb, opts] = [opts, undefined];
|
|
25
|
+
return (0, messaging_js_1.produce)(`publish ${topic}`, attrs(topic, 'send', 'publish', message), (h) => {
|
|
26
|
+
const o = opts;
|
|
27
|
+
const out = v5() ? { ...o, properties: { ...o?.properties, userProperties: { ...o?.properties?.userProperties, ...h } } } : o;
|
|
28
|
+
return cb === undefined ? orig.call(this, topic, message, out) : orig.call(this, topic, message, out ?? {}, cb);
|
|
29
|
+
});
|
|
30
|
+
});
|
|
31
|
+
// publishAsync calls publish, which then injects the context of this span
|
|
32
|
+
(0, db_js_1.patch)(client, 'publishAsync', (orig) => function (topic, message, ...rest) {
|
|
33
|
+
return (0, messaging_js_1.produce)(`publish ${topic}`, attrs(topic, 'send', 'publishAsync', message), () => orig.call(this, topic, message, ...rest));
|
|
34
|
+
});
|
|
35
|
+
(0, db_js_1.patch)(client, 'emit', (orig) => function (event, ...args) {
|
|
36
|
+
if (event !== 'message')
|
|
37
|
+
return orig.call(this, event, ...args);
|
|
38
|
+
const [topic, payload, packet] = args;
|
|
39
|
+
return (0, messaging_js_1.consume)(`process ${topic}`, attrs(topic, 'process', 'message', payload, packet?.messageId), [packet?.properties?.userProperties], () => orig.call(this, event, ...args));
|
|
40
|
+
});
|
|
41
|
+
}
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
interface MsgHdrs {
|
|
2
|
+
get(k: string): string;
|
|
3
|
+
set(k: string, v: string): void;
|
|
4
|
+
}
|
|
5
|
+
interface NatsModule {
|
|
6
|
+
headers(): MsgHdrs;
|
|
7
|
+
}
|
|
8
|
+
/**
|
|
9
|
+
* `instrumentNats(nc, nats)` (`import * as nats from 'nats'`; `nc = await nats.connect()`): patches the
|
|
10
|
+
* connection class. `publish`/`request` get PRODUCER spans with the context in NATS headers;
|
|
11
|
+
* `subscribe` messages get CONSUMER spans (child of and linked to the producer). With a `callback`
|
|
12
|
+
* subscription the span is active in the callback. With `for await (const m of sub)` each span runs
|
|
13
|
+
* from receipt to the next iteration and is not active in the loop body (child spans there are not
|
|
14
|
+
* parented to it; the producer link still gives lag).
|
|
15
|
+
*/
|
|
16
|
+
export declare function instrumentNats(nc: object, nats: NatsModule): void;
|
|
17
|
+
export {};
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.instrumentNats = instrumentNats;
|
|
4
|
+
const db_js_1 = require("./db.js");
|
|
5
|
+
const messaging_js_1 = require("./messaging.js");
|
|
6
|
+
const attrs = (subject, type, op, data, queue) => ({
|
|
7
|
+
'messaging.system': 'nats',
|
|
8
|
+
'messaging.destination.name': subject,
|
|
9
|
+
'messaging.operation.type': type,
|
|
10
|
+
'messaging.operation.name': op,
|
|
11
|
+
...(typeof data?.length === 'number' ? { 'messaging.message.body.size': data.length } : {}),
|
|
12
|
+
...(queue ? { 'messaging.consumer.group.name': queue } : {}),
|
|
13
|
+
});
|
|
14
|
+
const carrier = (m) => ({ traceparent: m.headers?.get('traceparent'), tracestate: m.headers?.get('tracestate') });
|
|
15
|
+
/**
|
|
16
|
+
* `instrumentNats(nc, nats)` (`import * as nats from 'nats'`; `nc = await nats.connect()`): patches the
|
|
17
|
+
* connection class. `publish`/`request` get PRODUCER spans with the context in NATS headers;
|
|
18
|
+
* `subscribe` messages get CONSUMER spans (child of and linked to the producer). With a `callback`
|
|
19
|
+
* subscription the span is active in the callback. With `for await (const m of sub)` each span runs
|
|
20
|
+
* from receipt to the next iteration and is not active in the loop body (child spans there are not
|
|
21
|
+
* parented to it; the producer link still gives lag).
|
|
22
|
+
*/
|
|
23
|
+
function instrumentNats(nc, nats) {
|
|
24
|
+
const proto = Object.getPrototypeOf(nc);
|
|
25
|
+
const withHeaders = (o, h) => {
|
|
26
|
+
const hdrs = o?.headers ?? nats.headers();
|
|
27
|
+
for (const [k, v] of Object.entries(h))
|
|
28
|
+
hdrs.set(k, v);
|
|
29
|
+
return { ...o, headers: hdrs };
|
|
30
|
+
};
|
|
31
|
+
(0, db_js_1.patch)(proto, 'publish', (orig) => function (subject, data, o) {
|
|
32
|
+
return (0, messaging_js_1.produce)(`send ${subject}`, attrs(subject, 'send', 'publish', data), (h) => orig.call(this, subject, data, withHeaders(o, h)));
|
|
33
|
+
});
|
|
34
|
+
(0, db_js_1.patch)(proto, 'request', (orig) => function (subject, data, o) {
|
|
35
|
+
return (0, messaging_js_1.produce)(`send ${subject}`, attrs(subject, 'send', 'request', data), (h) => orig.call(this, subject, data, withHeaders(o, h)));
|
|
36
|
+
});
|
|
37
|
+
(0, db_js_1.patch)(proto, 'subscribe', (orig) => function (subject, o) {
|
|
38
|
+
const cb = o?.callback;
|
|
39
|
+
if (typeof cb === 'function') {
|
|
40
|
+
const callback = (err, m) => (err || !m
|
|
41
|
+
? cb(err, m)
|
|
42
|
+
: (0, messaging_js_1.consume)(`process ${m.subject}`, attrs(m.subject, 'process', 'subscribe', m.data, o?.queue), [carrier(m)], () => cb(err, m)));
|
|
43
|
+
return orig.call(this, subject, { ...o, callback });
|
|
44
|
+
}
|
|
45
|
+
const sub = orig.call(this, subject, o);
|
|
46
|
+
const iter = sub[Symbol.asyncIterator]?.bind(sub);
|
|
47
|
+
if (!iter)
|
|
48
|
+
return sub;
|
|
49
|
+
sub[Symbol.asyncIterator] = () => {
|
|
50
|
+
const inner = iter();
|
|
51
|
+
let end;
|
|
52
|
+
const close = () => { end?.(); end = undefined; };
|
|
53
|
+
return {
|
|
54
|
+
async next() {
|
|
55
|
+
close();
|
|
56
|
+
const r = await inner.next();
|
|
57
|
+
if (!r.done) {
|
|
58
|
+
const m = r.value;
|
|
59
|
+
// the span ends when this promise resolves, i.e. on the next iteration or return
|
|
60
|
+
void (0, messaging_js_1.consume)(`process ${m.subject}`, attrs(m.subject, 'process', 'subscribe', m.data, o?.queue), [carrier(m)], () => new Promise((res) => { end = res; }));
|
|
61
|
+
}
|
|
62
|
+
return r;
|
|
63
|
+
},
|
|
64
|
+
async return(v) {
|
|
65
|
+
close();
|
|
66
|
+
return inner.return ? inner.return(v) : { done: true, value: v };
|
|
67
|
+
},
|
|
68
|
+
[Symbol.asyncIterator]() { return this; },
|
|
69
|
+
};
|
|
70
|
+
};
|
|
71
|
+
return sub;
|
|
72
|
+
});
|
|
73
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import type { DbOptions } from './db.js';
|
|
2
|
+
/**
|
|
3
|
+
* `instrumentDrizzle(db, 'postgresql')`: a CLIENT span per query a Drizzle database runs (`system`
|
|
4
|
+
* is the `db.system.name`: postgresql, mysql, sqlite, ...). Call once per `drizzle(...)` instance.
|
|
5
|
+
* shortcut: `db.transaction(tx => ...)` runs on its own session and gets no spans; instrument the
|
|
6
|
+
* driver as well if transactions matter.
|
|
7
|
+
*/
|
|
8
|
+
export declare function instrumentDrizzle(db: object, system: string, opts?: DbOptions): void;
|
|
9
|
+
interface KyselyLogEvent {
|
|
10
|
+
level: 'query' | 'error';
|
|
11
|
+
query: {
|
|
12
|
+
sql: string;
|
|
13
|
+
};
|
|
14
|
+
queryDurationMillis: number;
|
|
15
|
+
error?: unknown;
|
|
16
|
+
}
|
|
17
|
+
/** `new Kysely({ dialect, log: kyselyLog('postgresql') })`; `next` still gets every event. */
|
|
18
|
+
export declare function kyselyLog(system: string, next?: (e: KyselyLogEvent) => void, opts?: DbOptions): (e: KyselyLogEvent) => void;
|
|
19
|
+
interface DataSourceLike {
|
|
20
|
+
options: {
|
|
21
|
+
type: string;
|
|
22
|
+
database?: unknown;
|
|
23
|
+
};
|
|
24
|
+
driver: object;
|
|
25
|
+
}
|
|
26
|
+
/** `instrumentTypeORM(dataSource)` (before or after `initialize`): a CLIENT span per `QueryRunner.query`. */
|
|
27
|
+
export declare function instrumentTypeORM(dataSource: DataSourceLike, opts?: DbOptions): void;
|
|
28
|
+
/**
|
|
29
|
+
* `new Sequelize(url, { benchmark: true, logging: sequelizeLogging('postgresql') })`: a span per
|
|
30
|
+
* executed query (only lines with a timing, so `benchmark: true` is required). `next` gets every call.
|
|
31
|
+
* shortcut: failed queries are not logged by Sequelize with a timing, so they get no span.
|
|
32
|
+
*/
|
|
33
|
+
export declare function sequelizeLogging(system: string, next?: (sql: string, ...rest: unknown[]) => void, opts?: DbOptions): (sql: string, ...rest: unknown[]) => void;
|
|
34
|
+
interface MikroLogContext {
|
|
35
|
+
query?: string;
|
|
36
|
+
took?: number;
|
|
37
|
+
level?: string;
|
|
38
|
+
}
|
|
39
|
+
interface MikroLogger {
|
|
40
|
+
logQuery(context: MikroLogContext): void;
|
|
41
|
+
}
|
|
42
|
+
/**
|
|
43
|
+
* `MikroORM.init({ loggerFactory: mikroOrmLoggerFactory(DefaultLogger, 'postgresql') })`: a span per
|
|
44
|
+
* query MikroORM reports (with its `took`), then the `Base` logger logs as usual.
|
|
45
|
+
*/
|
|
46
|
+
export declare function mikroOrmLoggerFactory<O, L extends MikroLogger>(Base: new (options: O) => L, system: string, opts?: DbOptions): (options: O) => L;
|
|
47
|
+
export {};
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.instrumentDrizzle = instrumentDrizzle;
|
|
4
|
+
exports.kyselyLog = kyselyLog;
|
|
5
|
+
exports.instrumentTypeORM = instrumentTypeORM;
|
|
6
|
+
exports.sequelizeLogging = sequelizeLogging;
|
|
7
|
+
exports.mikroOrmLoggerFactory = mikroOrmLoggerFactory;
|
|
8
|
+
// ORM query spans: summary (`SELECT users`), `db.query.hash` and the N+1 hint from the shared core.
|
|
9
|
+
// The statement text is never recorded raw (with `queryText`, literal-free only).
|
|
10
|
+
const db_js_1 = require("./db.js");
|
|
11
|
+
const PREPARED = ['execute', 'all', 'get', 'run', 'values'];
|
|
12
|
+
/**
|
|
13
|
+
* `instrumentDrizzle(db, 'postgresql')`: a CLIENT span per query a Drizzle database runs (`system`
|
|
14
|
+
* is the `db.system.name`: postgresql, mysql, sqlite, ...). Call once per `drizzle(...)` instance.
|
|
15
|
+
* shortcut: `db.transaction(tx => ...)` runs on its own session and gets no spans; instrument the
|
|
16
|
+
* driver as well if transactions matter.
|
|
17
|
+
*/
|
|
18
|
+
function instrumentDrizzle(db, system, opts) {
|
|
19
|
+
const d = db;
|
|
20
|
+
const session = d.session ?? d._?.session;
|
|
21
|
+
if (!session)
|
|
22
|
+
return;
|
|
23
|
+
(0, db_js_1.patch)(session, 'prepareQuery', (orig) => function (query, ...rest) {
|
|
24
|
+
const pq = orig.call(this, query, ...rest);
|
|
25
|
+
if (pq && typeof pq === 'object') {
|
|
26
|
+
for (const m of PREPARED) {
|
|
27
|
+
(0, db_js_1.patch)(pq, m, (o) => function (...a) {
|
|
28
|
+
return (0, db_js_1.traced)({ system, sql: query?.sql }, opts, () => o.apply(this, a));
|
|
29
|
+
});
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
return pq;
|
|
33
|
+
});
|
|
34
|
+
}
|
|
35
|
+
/** `new Kysely({ dialect, log: kyselyLog('postgresql') })`; `next` still gets every event. */
|
|
36
|
+
function kyselyLog(system, next, opts) {
|
|
37
|
+
return (e) => {
|
|
38
|
+
(0, db_js_1.recordDbSpan)({ system, sql: e.query?.sql }, opts, e.queryDurationMillis, e.level === 'error' ? e.error ?? new Error() : undefined);
|
|
39
|
+
next?.(e);
|
|
40
|
+
};
|
|
41
|
+
}
|
|
42
|
+
const TYPEORM = {
|
|
43
|
+
postgres: 'postgresql', 'aurora-postgres': 'postgresql', cockroachdb: 'cockroachdb',
|
|
44
|
+
mysql: 'mysql', 'aurora-mysql': 'mysql', mariadb: 'mariadb', mssql: 'microsoft.sql_server',
|
|
45
|
+
oracle: 'oracle.db', sap: 'sap.hana', spanner: 'gcp.spanner', 'better-sqlite3': 'sqlite', sqlite: 'sqlite',
|
|
46
|
+
sqljs: 'sqlite', capacitor: 'sqlite', cordova: 'sqlite', expo: 'sqlite', nativescript: 'sqlite', 'react-native': 'sqlite',
|
|
47
|
+
};
|
|
48
|
+
/** `instrumentTypeORM(dataSource)` (before or after `initialize`): a CLIENT span per `QueryRunner.query`. */
|
|
49
|
+
function instrumentTypeORM(dataSource, opts) {
|
|
50
|
+
const { type, database } = dataSource.options;
|
|
51
|
+
const system = TYPEORM[type] ?? type;
|
|
52
|
+
const namespace = typeof database === 'string' ? database : undefined;
|
|
53
|
+
(0, db_js_1.patch)(dataSource.driver, 'createQueryRunner', (orig) => function (...args) {
|
|
54
|
+
const runner = orig.apply(this, args);
|
|
55
|
+
if (runner && typeof runner === 'object') {
|
|
56
|
+
(0, db_js_1.patch)(runner, 'query', (q) => function (sql, ...rest) {
|
|
57
|
+
return (0, db_js_1.traced)({ system, sql, namespace }, opts, () => q.call(this, sql, ...rest));
|
|
58
|
+
});
|
|
59
|
+
}
|
|
60
|
+
return runner;
|
|
61
|
+
});
|
|
62
|
+
}
|
|
63
|
+
const EXECUTED = /^Execut(?:ed|ing) \([^)]*\):\s*/;
|
|
64
|
+
/**
|
|
65
|
+
* `new Sequelize(url, { benchmark: true, logging: sequelizeLogging('postgresql') })`: a span per
|
|
66
|
+
* executed query (only lines with a timing, so `benchmark: true` is required). `next` gets every call.
|
|
67
|
+
* shortcut: failed queries are not logged by Sequelize with a timing, so they get no span.
|
|
68
|
+
*/
|
|
69
|
+
function sequelizeLogging(system, next, opts) {
|
|
70
|
+
return (sql, ...rest) => {
|
|
71
|
+
if (typeof rest[0] === 'number' && typeof sql === 'string') {
|
|
72
|
+
(0, db_js_1.recordDbSpan)({ system, sql: sql.replace(EXECUTED, '') }, opts, rest[0]);
|
|
73
|
+
}
|
|
74
|
+
next?.(sql, ...rest);
|
|
75
|
+
};
|
|
76
|
+
}
|
|
77
|
+
/**
|
|
78
|
+
* `MikroORM.init({ loggerFactory: mikroOrmLoggerFactory(DefaultLogger, 'postgresql') })`: a span per
|
|
79
|
+
* query MikroORM reports (with its `took`), then the `Base` logger logs as usual.
|
|
80
|
+
*/
|
|
81
|
+
function mikroOrmLoggerFactory(Base, system, opts) {
|
|
82
|
+
return (options) => {
|
|
83
|
+
const logger = new Base(options);
|
|
84
|
+
const logQuery = logger.logQuery.bind(logger);
|
|
85
|
+
logger.logQuery = (c) => {
|
|
86
|
+
if (c && typeof c.query === 'string' && typeof c.took === 'number') {
|
|
87
|
+
(0, db_js_1.recordDbSpan)({ system, sql: c.query }, opts, c.took, c.level === 'error' ? new Error() : undefined);
|
|
88
|
+
}
|
|
89
|
+
logQuery(c);
|
|
90
|
+
};
|
|
91
|
+
return logger;
|
|
92
|
+
};
|
|
93
|
+
}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `instrumentPgBoss(boss)`: PRODUCER spans on `send` and `insert` (context in job data under `_wt`,
|
|
3
|
+
* object data only), and a CONSUMER span around each `work` handler call, child of the producer for
|
|
4
|
+
* a single job and linked to every job's producer for a batch. `_wt` is removed before the handler
|
|
5
|
+
* sees `job.data`. `messaging.system` is `pg-boss` (OTel has no value for it).
|
|
6
|
+
* shortcut: sendAfter/sendThrottled/sendDebounced/sendSingleton bypass `send`; their jobs carry no context.
|
|
7
|
+
*/
|
|
8
|
+
export declare function instrumentPgBoss(boss: object): void;
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.instrumentPgBoss = instrumentPgBoss;
|
|
4
|
+
const api_1 = require("@opentelemetry/api");
|
|
5
|
+
const db_js_1 = require("./db.js");
|
|
6
|
+
const messaging_js_1 = require("./messaging.js");
|
|
7
|
+
const attrs = (queue, type, op) => ({
|
|
8
|
+
'messaging.system': 'pg-boss',
|
|
9
|
+
'messaging.destination.name': queue,
|
|
10
|
+
'messaging.operation.type': type,
|
|
11
|
+
'messaging.operation.name': op,
|
|
12
|
+
});
|
|
13
|
+
/** Run `call` and set the returned job id on the active (producer) span. */
|
|
14
|
+
function withId(call) {
|
|
15
|
+
const span = api_1.trace.getActiveSpan();
|
|
16
|
+
return call().then((id) => {
|
|
17
|
+
if (typeof id === 'string')
|
|
18
|
+
span?.setAttribute('messaging.message.id', id);
|
|
19
|
+
return id;
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
/**
|
|
23
|
+
* `instrumentPgBoss(boss)`: PRODUCER spans on `send` and `insert` (context in job data under `_wt`,
|
|
24
|
+
* object data only), and a CONSUMER span around each `work` handler call, child of the producer for
|
|
25
|
+
* a single job and linked to every job's producer for a batch. `_wt` is removed before the handler
|
|
26
|
+
* sees `job.data`. `messaging.system` is `pg-boss` (OTel has no value for it).
|
|
27
|
+
* shortcut: sendAfter/sendThrottled/sendDebounced/sendSingleton bypass `send`; their jobs carry no context.
|
|
28
|
+
*/
|
|
29
|
+
function instrumentPgBoss(boss) {
|
|
30
|
+
(0, db_js_1.patch)(boss, 'send', (orig) => function (nameOrReq, data, ...rest) {
|
|
31
|
+
if (typeof nameOrReq === 'object' && nameOrReq) {
|
|
32
|
+
const req = nameOrReq;
|
|
33
|
+
return (0, messaging_js_1.produce)(`send ${req.name}`, attrs(req.name, 'send', 'send'), () => withId(() => orig.call(this, { ...req, data: (0, messaging_js_1.injectData)(req.data) }, data, ...rest)));
|
|
34
|
+
}
|
|
35
|
+
return (0, messaging_js_1.produce)(`send ${nameOrReq}`, attrs(nameOrReq, 'send', 'send'), () => withId(() => orig.call(this, nameOrReq, (0, messaging_js_1.injectData)(data), ...rest)));
|
|
36
|
+
});
|
|
37
|
+
// v9: insert(jobs[]); v10: insert(name, jobs[])
|
|
38
|
+
(0, db_js_1.patch)(boss, 'insert', (orig) => function (a, b, ...rest) {
|
|
39
|
+
const jobs = (Array.isArray(a) ? a : b);
|
|
40
|
+
const queue = typeof a === 'string' ? a : jobs?.[0]?.name ?? '';
|
|
41
|
+
const at = { ...attrs(queue, 'send', 'insert'), 'messaging.batch.message_count': jobs?.length ?? 0 };
|
|
42
|
+
return (0, messaging_js_1.produce)(`send ${queue}`, at, () => {
|
|
43
|
+
const out = jobs?.map((j) => ({ ...j, data: (0, messaging_js_1.injectData)(j.data) }));
|
|
44
|
+
return Array.isArray(a) ? orig.call(this, out, b, ...rest) : orig.call(this, a, out, ...rest);
|
|
45
|
+
});
|
|
46
|
+
});
|
|
47
|
+
(0, db_js_1.patch)(boss, 'work', (orig) => function (name, ...rest) {
|
|
48
|
+
const i = rest.length - 1;
|
|
49
|
+
const handler = rest[i];
|
|
50
|
+
if (typeof handler !== 'function')
|
|
51
|
+
return orig.call(this, name, ...rest);
|
|
52
|
+
rest[i] = function (arg) {
|
|
53
|
+
const jobs = Array.isArray(arg) ? arg : [arg];
|
|
54
|
+
const a = attrs(name, 'process', 'work');
|
|
55
|
+
if (jobs.length === 1 && jobs[0]?.id)
|
|
56
|
+
a['messaging.message.id'] = jobs[0].id;
|
|
57
|
+
if (Array.isArray(arg))
|
|
58
|
+
a['messaging.batch.message_count'] = arg.length;
|
|
59
|
+
return (0, messaging_js_1.consume)(`process ${name}`, a, jobs.map((j) => (0, messaging_js_1.takeContext)(j?.data)), () => handler.call(this, arg));
|
|
60
|
+
};
|
|
61
|
+
return orig.call(this, name, ...rest);
|
|
62
|
+
});
|
|
63
|
+
}
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
import { observePool } from './db.js';
|
|
2
|
+
import type { PoolState } from './db.js';
|
|
3
|
+
export { observePool };
|
|
4
|
+
export type { PoolState };
|
|
5
|
+
interface Emitter {
|
|
6
|
+
on(event: string, fn: (e: any) => void): unknown;
|
|
7
|
+
}
|
|
8
|
+
/**
|
|
9
|
+
* `instrumentMongoPool(client)` on a `MongoClient` (before or after `connect`): pool gauges per
|
|
10
|
+
* server address from the driver's CMAP events, wait time (driver >= 6.9 reports `durationMS`),
|
|
11
|
+
* use time (check-out to check-in) and check-out timeouts. Call after `init`.
|
|
12
|
+
*/
|
|
13
|
+
export declare function instrumentMongoPool(client: Emitter): void;
|
|
14
|
+
interface Mysql2CorePool extends Emitter {
|
|
15
|
+
_allConnections?: {
|
|
16
|
+
length: number;
|
|
17
|
+
};
|
|
18
|
+
_freeConnections?: {
|
|
19
|
+
length: number;
|
|
20
|
+
};
|
|
21
|
+
_connectionQueue?: {
|
|
22
|
+
length: number;
|
|
23
|
+
};
|
|
24
|
+
config?: {
|
|
25
|
+
connectionLimit?: number;
|
|
26
|
+
connectionConfig?: {
|
|
27
|
+
host?: string;
|
|
28
|
+
port?: number;
|
|
29
|
+
database?: string;
|
|
30
|
+
};
|
|
31
|
+
};
|
|
32
|
+
}
|
|
33
|
+
/**
|
|
34
|
+
* `instrumentMysql2Pool(pool)` on a mysql2 pool (callback or `.promise()` pool): used/idle/pending
|
|
35
|
+
* connections and the limit, plus use time (acquire to release). Name defaults to `host:port/db`.
|
|
36
|
+
* shortcut: no wait time or timeouts (mysql2 has no acquire timeout and does not report queue wait).
|
|
37
|
+
* Returns `stop()`.
|
|
38
|
+
*/
|
|
39
|
+
export declare function instrumentMysql2Pool(pool: Mysql2CorePool | {
|
|
40
|
+
pool: Mysql2CorePool;
|
|
41
|
+
}, name?: string): () => void;
|
|
@@ -0,0 +1,94 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.observePool = void 0;
|
|
4
|
+
exports.instrumentMongoPool = instrumentMongoPool;
|
|
5
|
+
exports.instrumentMysql2Pool = instrumentMysql2Pool;
|
|
6
|
+
// Connection-pool metrics (OTel db semconv) for drivers whose pools upstream does not cover.
|
|
7
|
+
const db_js_1 = require("./db.js");
|
|
8
|
+
Object.defineProperty(exports, "observePool", { enumerable: true, get: function () { return db_js_1.observePool; } });
|
|
9
|
+
/**
|
|
10
|
+
* `instrumentMongoPool(client)` on a `MongoClient` (before or after `connect`): pool gauges per
|
|
11
|
+
* server address from the driver's CMAP events, wait time (driver >= 6.9 reports `durationMS`),
|
|
12
|
+
* use time (check-out to check-in) and check-out timeouts. Call after `init`.
|
|
13
|
+
*/
|
|
14
|
+
function instrumentMongoPool(client) {
|
|
15
|
+
const pools = new Map();
|
|
16
|
+
const out = new Map(); // `${address}#${connectionId}` -> checked out at (ms)
|
|
17
|
+
const get = (address) => {
|
|
18
|
+
let p = pools.get(address);
|
|
19
|
+
if (!p) {
|
|
20
|
+
const s = { used: 0, pending: 0, total: 0 };
|
|
21
|
+
s.rec = (0, db_js_1.observePool)('mongodb', address, () => ({
|
|
22
|
+
used: s.used, idle: Math.max(0, s.total - s.used), pending: s.pending, max: s.max,
|
|
23
|
+
}));
|
|
24
|
+
pools.set(address, (p = s));
|
|
25
|
+
}
|
|
26
|
+
return p;
|
|
27
|
+
};
|
|
28
|
+
const dec = (n) => Math.max(0, n - 1);
|
|
29
|
+
client.on('connectionPoolCreated', (e) => {
|
|
30
|
+
const max = e.options?.maxPoolSize;
|
|
31
|
+
if (typeof max === 'number')
|
|
32
|
+
get(e.address).max = max;
|
|
33
|
+
});
|
|
34
|
+
client.on('connectionPoolClosed', (e) => {
|
|
35
|
+
pools.get(e.address)?.rec.stop();
|
|
36
|
+
pools.delete(e.address);
|
|
37
|
+
});
|
|
38
|
+
client.on('connectionCreated', (e) => { get(e.address).total++; });
|
|
39
|
+
client.on('connectionClosed', (e) => { const p = get(e.address); p.total = dec(p.total); });
|
|
40
|
+
client.on('connectionCheckOutStarted', (e) => { get(e.address).pending++; });
|
|
41
|
+
client.on('connectionCheckOutFailed', (e) => {
|
|
42
|
+
const p = get(e.address);
|
|
43
|
+
p.pending = dec(p.pending);
|
|
44
|
+
if (e.reason === 'timeout')
|
|
45
|
+
p.rec.timeout();
|
|
46
|
+
if (typeof e.durationMS === 'number')
|
|
47
|
+
p.rec.wait(e.durationMS / 1000);
|
|
48
|
+
});
|
|
49
|
+
client.on('connectionCheckedOut', (e) => {
|
|
50
|
+
const p = get(e.address);
|
|
51
|
+
p.pending = dec(p.pending);
|
|
52
|
+
p.used++;
|
|
53
|
+
if (typeof e.durationMS === 'number')
|
|
54
|
+
p.rec.wait(e.durationMS / 1000);
|
|
55
|
+
out.set(`${e.address}#${e.connectionId}`, Date.now());
|
|
56
|
+
});
|
|
57
|
+
client.on('connectionCheckedIn', (e) => {
|
|
58
|
+
const p = get(e.address);
|
|
59
|
+
p.used = dec(p.used);
|
|
60
|
+
const k = `${e.address}#${e.connectionId}`;
|
|
61
|
+
const t = out.get(k);
|
|
62
|
+
if (t !== undefined) {
|
|
63
|
+
out.delete(k);
|
|
64
|
+
p.rec.use((Date.now() - t) / 1000);
|
|
65
|
+
}
|
|
66
|
+
});
|
|
67
|
+
}
|
|
68
|
+
/**
|
|
69
|
+
* `instrumentMysql2Pool(pool)` on a mysql2 pool (callback or `.promise()` pool): used/idle/pending
|
|
70
|
+
* connections and the limit, plus use time (acquire to release). Name defaults to `host:port/db`.
|
|
71
|
+
* shortcut: no wait time or timeouts (mysql2 has no acquire timeout and does not report queue wait).
|
|
72
|
+
* Returns `stop()`.
|
|
73
|
+
*/
|
|
74
|
+
function instrumentMysql2Pool(pool, name) {
|
|
75
|
+
const core = ('pool' in pool && pool.pool ? pool.pool : pool);
|
|
76
|
+
const c = core.config?.connectionConfig;
|
|
77
|
+
const pname = name ?? (c ? `${c.host ?? 'localhost'}:${c.port ?? 3306}${c.database ? `/${c.database}` : ''}` : 'mysql2');
|
|
78
|
+
const rec = (0, db_js_1.observePool)('mysql', pname, () => {
|
|
79
|
+
const all = core._allConnections?.length ?? 0;
|
|
80
|
+
const free = core._freeConnections?.length ?? 0;
|
|
81
|
+
return { used: all - free, idle: free, pending: core._connectionQueue?.length ?? 0, max: core.config?.connectionLimit };
|
|
82
|
+
});
|
|
83
|
+
const acquired = new WeakMap();
|
|
84
|
+
core.on('acquire', (conn) => { if (conn)
|
|
85
|
+
acquired.set(conn, Date.now()); });
|
|
86
|
+
core.on('release', (conn) => {
|
|
87
|
+
const t = conn && acquired.get(conn);
|
|
88
|
+
if (t) {
|
|
89
|
+
acquired.delete(conn);
|
|
90
|
+
rec.use((Date.now() - t) / 1000);
|
|
91
|
+
}
|
|
92
|
+
});
|
|
93
|
+
return rec.stop;
|
|
94
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import { querySummary } from '../sql.js';
|
|
2
|
+
import type { DbOptions } from './db.js';
|
|
3
|
+
export { querySummary };
|
|
4
|
+
/**
|
|
5
|
+
* postgres.js has no OTel instrumentation; since 4.0 it publishes each query on the
|
|
6
|
+
* `postgres:query` diagnostics tracing channel. This turns those into CLIENT spans (child of the
|
|
7
|
+
* active span) with `db.system=postgresql`, the operation, a summary and `db.query.hash` (no
|
|
8
|
+
* statement text or parameters unless `opts.queryText`, then literal-free) and the SQLSTATE on
|
|
9
|
+
* failure. Works for ESM and CJS; returns an unsubscribe function (a no-op when this Node has no
|
|
10
|
+
* tracing channels).
|
|
11
|
+
*/
|
|
12
|
+
export declare function instrumentPostgres(opts?: DbOptions): () => void;
|