@moostjs/otel 0.4.0

package/README.md

@@ -0,0 +1 @@
+# @moostjs/otel

package/dist/index.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var api = require('@opentelemetry/api');
+var moost = require('moost');
+
+function useOtelContext() {
+    const store = moost.useAsyncEventContext().store('otel');
+    const getSpan = () => store.get('span');
+    const getSpanContext = () => {
+        const span = getSpan();
+        if (span) {
+            return span.spanContext();
+        }
+    };
+    const getPropagationHeaders = () => {
+        const c = getSpanContext();
+        if (c) {
+            return {
+                traceparent: `00-${c.traceId}-${c.spanId}-${c.traceFlags}`,
+                tracestate: c.traceState,
+            };
+        }
+        return {};
+    };
+    return {
+        trace: api.trace,
+        withChildSpan: (name, cb, opts) => {
+            const parentSpan = getSpan();
+            if (parentSpan) {
+                const tracer = api.trace.getTracer('moost-tracer');
+                const span = tracer.startSpan(name, opts);
+                return () => api.context.with(api.trace.setSpan(api.context.active(), span), () => cb());
+            }
+            else {
+                return cb();
+            }
+        },
+        getSpan,
+        getSpanContext,
+        getPropagationHeaders,
+        registerSpan: (span) => store.set('span', span),
+    };
+}
+function useTrace() {
+    return api.trace;
+}
+function useSpan() {
+    return useOtelContext().getSpan();
+}
+function useOtelPropagation() {
+    const { getPropagationHeaders, getSpanContext } = useOtelContext();
+    return {
+        ...getSpanContext(),
+        headers: getPropagationHeaders(),
+    };
+}
+
+function enableOtelForMoost() {
+    moost.eventContextHooks.onStartEvent((eventType) => {
+        const { registerSpan } = useOtelContext();
+        let span;
+        if (eventType === 'HTTP') {
+            span = api.trace.getSpan(api.context.active());
+        }
+        else {
+            const tracer = api.trace.getTracer('moost-tracer');
+            span = tracer.startSpan(`${eventType} Event`);
+        }
+        if (span) {
+            registerSpan(span);
+        }
+    });
+    moost.eventContextHooks.onEndEvent((eventType, abortReason) => {
+        const { getSpan } = useOtelContext();
+        const span = getSpan();
+        if (span) {
+            const { getMethod, getMethodMeta, getController } = moost.useControllerContext();
+            const methodName = getMethod();
+            const methodMeta = getMethodMeta();
+            span.setAttributes({
+                'custom.event_type': eventType,
+                'custom.event_description': methodMeta?.description || methodMeta?.label || methodName,
+                'moost.controller': moost.getConstructor(getController()).name,
+                'moost.handler': methodName,
+            });
+            if (abortReason) {
+                span.recordException(new Error(abortReason));
+                span.setStatus({ code: api.SpanStatusCode.ERROR, message: abortReason });
+            }
+            if (eventType === 'HTTP') {
+                const req = moost.useAsyncEventContext()
+                    .store('event')
+                    .get('req');
+                span.updateName(`${req?.method || ''} ${methodMeta?.id || methodMeta?.label || methodName}`);
+            }
+            else {
+                span.updateName(`${methodMeta?.label || methodName}`);
+                span.end();
+            }
+        }
+    });
+}
+
+exports.enableOtelForMoost = enableOtelForMoost;
+exports.useOtelContext = useOtelContext;
+exports.useOtelPropagation = useOtelPropagation;
+exports.useSpan = useSpan;
+exports.useTrace = useTrace;

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { Span, SpanOptions } from '@opentelemetry/api';
+
+interface TOtelContext {
+    otel?: {
+        span?: Span;
+    };
+}
+declare function useOtelContext(): {
+    trace: _opentelemetry_api.TraceAPI;
+    withChildSpan: <T>(name: string, cb: (...a: any[]) => T, opts?: SpanOptions) => T | (() => T);
+    getSpan: () => Span | undefined;
+    getSpanContext: () => _opentelemetry_api.SpanContext | undefined;
+    getPropagationHeaders: () => {
+        traceparent: string;
+        tracestate: _opentelemetry_api.TraceState | undefined;
+    } | {
+        traceparent?: undefined;
+        tracestate?: undefined;
+    };
+    registerSpan: (span: Span) => unknown;
+};
+declare function useTrace(): _opentelemetry_api.TraceAPI;
+declare function useSpan(): Span | undefined;
+declare function useOtelPropagation(): {
+    headers: {
+        traceparent: string;
+        tracestate: _opentelemetry_api.TraceState | undefined;
+    } | {
+        traceparent?: undefined;
+        tracestate?: undefined;
+    };
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+    isRemote?: boolean | undefined;
+    traceFlags?: number | undefined;
+    traceState?: _opentelemetry_api.TraceState | undefined;
+};
+
+declare function enableOtelForMoost(): void;
+
+export { type TOtelContext, enableOtelForMoost, useOtelContext, useOtelPropagation, useSpan, useTrace };

package/dist/index.mjs

@@ -0,0 +1,102 @@
+import { trace, context, SpanStatusCode } from '@opentelemetry/api';
+import { useAsyncEventContext, eventContextHooks, useControllerContext, getConstructor } from 'moost';
+
+function useOtelContext() {
+    const store = useAsyncEventContext().store('otel');
+    const getSpan = () => store.get('span');
+    const getSpanContext = () => {
+        const span = getSpan();
+        if (span) {
+            return span.spanContext();
+        }
+    };
+    const getPropagationHeaders = () => {
+        const c = getSpanContext();
+        if (c) {
+            return {
+                traceparent: `00-${c.traceId}-${c.spanId}-${c.traceFlags}`,
+                tracestate: c.traceState,
+            };
+        }
+        return {};
+    };
+    return {
+        trace,
+        withChildSpan: (name, cb, opts) => {
+            const parentSpan = getSpan();
+            if (parentSpan) {
+                const tracer = trace.getTracer('moost-tracer');
+                const span = tracer.startSpan(name, opts);
+                return () => context.with(trace.setSpan(context.active(), span), () => cb());
+            }
+            else {
+                return cb();
+            }
+        },
+        getSpan,
+        getSpanContext,
+        getPropagationHeaders,
+        registerSpan: (span) => store.set('span', span),
+    };
+}
+function useTrace() {
+    return trace;
+}
+function useSpan() {
+    return useOtelContext().getSpan();
+}
+function useOtelPropagation() {
+    const { getPropagationHeaders, getSpanContext } = useOtelContext();
+    return {
+        ...getSpanContext(),
+        headers: getPropagationHeaders(),
+    };
+}
+
+function enableOtelForMoost() {
+    eventContextHooks.onStartEvent((eventType) => {
+        const { registerSpan } = useOtelContext();
+        let span;
+        if (eventType === 'HTTP') {
+            span = trace.getSpan(context.active());
+        }
+        else {
+            const tracer = trace.getTracer('moost-tracer');
+            span = tracer.startSpan(`${eventType} Event`);
+        }
+        if (span) {
+            registerSpan(span);
+        }
+    });
+    eventContextHooks.onEndEvent((eventType, abortReason) => {
+        const { getSpan } = useOtelContext();
+        const span = getSpan();
+        if (span) {
+            const { getMethod, getMethodMeta, getController } = useControllerContext();
+            const methodName = getMethod();
+            const methodMeta = getMethodMeta();
+            span.setAttributes({
+                'custom.event_type': eventType,
+                'custom.event_description': methodMeta?.description || methodMeta?.label || methodName,
+                'moost.controller': getConstructor(getController()).name,
+                'moost.handler': methodName,
+            });
+            if (abortReason) {
+                span.recordException(new Error(abortReason));
+                span.setStatus({ code: SpanStatusCode.ERROR, message: abortReason });
+            }
+            if (eventType === 'HTTP') {
+                const req = useAsyncEventContext()
+                    .store('event')
+                    .get('req');
+                span.updateName(`${req?.method || ''} ${methodMeta?.id || methodMeta?.label || methodName}`);
+            }
+            else {
+                span.updateName(`${methodMeta?.label || methodName}`);
+                span.end();
+            }
+        }
+    });
+}
+
+export { enableOtelForMoost, useOtelContext, useOtelPropagation, useSpan, useTrace };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@moostjs/otel",
+  "version": "0.4.0",
+  "description": "@moostjs/otel",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/moostjs.git",
+    "directory": "packages/otel"
+  },
+  "keywords": [
+    "moost",
+    "moostjs",
+    "composables",
+    "framework",
+    "wooksjs",
+    "prostojs"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/moostjs/moostjs/issues"
+  },
+  "homepage": "https://github.com/moostjs/moostjs/tree/main/packages/otel#readme",
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "moost": "0.4.0"
+  }
+}