rian 0.0.4 → 0.1.1

package/exporter.otel.http.js

@@ -19,7 +19,7 @@ const convert_value_to_anyvalue = (value) => {
         any_value.arrayValue = {
             values: value.map((i) => convert_value_to_anyvalue(i)),
         };
-    else
+    else if (value)
         any_value.kvlistValue = { values: convert_object_to_kv(value) };
     return any_value;
 };
@@ -79,6 +79,7 @@ const exporter = (request) => (spans, context) => {
             droppedEventsCount: 0,
             droppedLinksCount: 0,
             attributes: convert_object_to_kv(span_ctx),
+            // @ts-expect-error TS2454
             status: status || { code: SpanStatusCode_UNSET },
             events: span.events.map((i) => ({
                 name: i.name,

package/exporter.otel.http.mjs

@@ -17,7 +17,7 @@ const convert_value_to_anyvalue = (value) => {
         any_value.arrayValue = {
             values: value.map((i) => convert_value_to_anyvalue(i)),
         };
-    else
+    else if (value)
         any_value.kvlistValue = { values: convert_object_to_kv(value) };
     return any_value;
 };
@@ -77,6 +77,7 @@ const exporter = (request) => (spans, context) => {
             droppedEventsCount: 0,
             droppedLinksCount: 0,
             attributes: convert_object_to_kv(span_ctx),
+            // @ts-expect-error TS2454
             status: status || { code: SpanStatusCode_UNSET },
             events: span.events.map((i) => ({
                 name: i.name,

package/index.d.ts

@@ -1,8 +1,4 @@
 import { Traceparent } from 'tctx';
-import { Scope as Scope$1 } from 'rian';
-
-declare type MeasureFn = ((...args: [...args: any[]]) => any) | ((...args: [...args: any[], scope: Scope$1]) => any);
-declare type RealMeasureFnParams<T extends unknown[]> = T extends [] ? [] : T extends [...rest: infer U, scope: Scope$1] ? U : T;
 
 /**
  * Spans are units within a distributed trace. Spans encapsulate mainly 3 pieces of information, a
@@ -96,30 +92,6 @@ interface Scope {
      * Forks the span into a new child span.
      */
     fork(name: string): CallableScope;
-    /**
-     * With a passed function — will start a span, and run the function, when the function finishes
-     * the span finishes.
-     *
-     * The measure method will return whatever the function is, so if it's a promise, it returns a
-     * promise and so on. Any error is caught and re thrown, and automatically tracked in the
-     * context under the `error` property.
-     *
-     * All promises are tracked, and awaited on a `tracer.end`.
-     *
-     * @example
-     *
-     * ```text
-     * const data = await scope.measure('name', get_data, 'user_id_123');
-     *        ^                           ^        ^          ^
-     *        |                           |        |          |
-     *        |                           |        |          the first argument to get_data
-     *        |                           |        function to be called
-     *        |                           the name of the sub scope
-     *        return value from get_data
-     * ```
-     */
-    measure<Fn extends MeasureFn>(name: string, fn: Fn, // TODO: fn doesnt see scope correctly
-    ...args: RealMeasureFnParams<Parameters<Fn>>): ReturnType<Fn>;
     /**
      * Allows the span's context to be set. Passing an object will be `Object.assign`ed into the
      * current context.
@@ -170,7 +142,7 @@ interface Options {
     /**
      * @borrows {@link Sampler}
      */
-    sampler?: Sampler;
+    sampler?: Sampler | boolean;
     context?: Context;
     /**
      * A root, or extracted w3c traceparent stringed header.

package/index.js

@@ -2,6 +2,7 @@
 
 const package_json = require('rian/package.json');
 const tctx = require('tctx');
+const utils = require('rian/utils');
 
 function _interopNamespace(e) {
 	if (e && e.__esModule) return e;
@@ -23,32 +24,20 @@ function _interopNamespace(e) {
 
 const tctx__namespace = /*#__PURE__*/_interopNamespace(tctx);
 
-const set_error = (scope, error) => {
-    scope.set_context({
-        error,
-    });
-};
-const measure = (fn, // TODO: fn doesnt see scope correctly
-scope, promises, ...args) => {
-    try {
-        var r = fn(...args, scope), is_promise = r instanceof Promise;
-        if (is_promise)
-            promises.push(r
-                .catch((e) => void set_error(scope, e))
-                .finally(() => scope.end()));
-        return r;
-    }
-    catch (e) {
-        set_error(scope, e);
-        throw e;
-    }
-    finally {
-        if (is_promise !== true)
-            scope.end();
-    }
-};
-
 // ==> impl
+/**
+ * @internal
+ */
+const PROMISES = new WeakMap();
+/**
+ * @internal
+ */
+const ADD_PROMISE = (scope, promise) => {
+    if (PROMISES.has(scope))
+        PROMISES.get(scope).push(promise);
+    else
+        PROMISES.set(scope, [promise]);
+};
 /**
  * The default sampler;
  *
@@ -70,10 +59,12 @@ const sdk_object = {
 };
 const create = (name, options) => {
     const spans = new Set();
-    const promises = [];
     const sampler = options.sampler || defaultSampler;
+    const sampler_callable = typeof sampler !== 'boolean';
     const span = (name, parent) => {
-        const should_sample = sampler(name, parent, options.context);
+        const should_sample = sampler_callable
+            ? sampler(name, parent, options.context)
+            : sampler;
         const id = parent
             ? parent.child(should_sample)
             : tctx__namespace.make(should_sample);
@@ -87,10 +78,10 @@ const create = (name, options) => {
         };
         if (should_sample)
             spans.add(span_obj);
-        const $ = (cb) => measure(cb, $, promises);
+        const $ = (cb) => utils.measureFn($, cb);
         $.traceparent = id;
         $.fork = (name) => span(name, id);
-        $.measure = (name, cb, ...args) => measure(cb, span(name, id), promises, ...args);
+        // @ts-expect-error TS7030 its always undefined ts :eye-roll:
         $.set_context = (ctx) => {
             if (typeof ctx === 'function')
                 return void (span_obj.context = ctx(span_obj.context));
@@ -104,9 +95,8 @@ const create = (name, options) => {
             });
         };
         $.end = () => {
-            if (span_obj.end)
-                return void 0;
-            span_obj.end = Date.now();
+            if (span_obj.end == null)
+                span_obj.end = Date.now();
         };
         return $;
     };
@@ -116,7 +106,8 @@ const create = (name, options) => {
     const endRoot = root.end.bind(root);
     root.end = async () => {
         endRoot();
-        await Promise.all(promises);
+        if (PROMISES.has(root))
+            await Promise.all(PROMISES.get(root));
         return options.exporter(spans, {
             ...(options.context || {}),
             ...sdk_object,
@@ -125,4 +116,6 @@ const create = (name, options) => {
     return root;
 };
 
+exports.ADD_PROMISE = ADD_PROMISE;
+exports.PROMISES = PROMISES;
 exports.create = create;

package/index.mjs

@@ -1,32 +1,21 @@
 import { name, version } from 'rian/package.json';
 import * as tctx from 'tctx';
-
-const set_error = (scope, error) => {
-    scope.set_context({
-        error,
-    });
-};
-const measure = (fn, // TODO: fn doesnt see scope correctly
-scope, promises, ...args) => {
-    try {
-        var r = fn(...args, scope), is_promise = r instanceof Promise;
-        if (is_promise)
-            promises.push(r
-                .catch((e) => void set_error(scope, e))
-                .finally(() => scope.end()));
-        return r;
-    }
-    catch (e) {
-        set_error(scope, e);
-        throw e;
-    }
-    finally {
-        if (is_promise !== true)
-            scope.end();
-    }
-};
+import { measureFn } from 'rian/utils';
 
 // ==> impl
+/**
+ * @internal
+ */
+const PROMISES = new WeakMap();
+/**
+ * @internal
+ */
+const ADD_PROMISE = (scope, promise) => {
+    if (PROMISES.has(scope))
+        PROMISES.get(scope).push(promise);
+    else
+        PROMISES.set(scope, [promise]);
+};
 /**
  * The default sampler;
  *
@@ -48,10 +37,12 @@ const sdk_object = {
 };
 const create = (name, options) => {
     const spans = new Set();
-    const promises = [];
     const sampler = options.sampler || defaultSampler;
+    const sampler_callable = typeof sampler !== 'boolean';
     const span = (name, parent) => {
-        const should_sample = sampler(name, parent, options.context);
+        const should_sample = sampler_callable
+            ? sampler(name, parent, options.context)
+            : sampler;
         const id = parent
             ? parent.child(should_sample)
             : tctx.make(should_sample);
@@ -65,10 +56,10 @@ const create = (name, options) => {
         };
         if (should_sample)
             spans.add(span_obj);
-        const $ = (cb) => measure(cb, $, promises);
+        const $ = (cb) => measureFn($, cb);
         $.traceparent = id;
         $.fork = (name) => span(name, id);
-        $.measure = (name, cb, ...args) => measure(cb, span(name, id), promises, ...args);
+        // @ts-expect-error TS7030 its always undefined ts :eye-roll:
         $.set_context = (ctx) => {
             if (typeof ctx === 'function')
                 return void (span_obj.context = ctx(span_obj.context));
@@ -82,9 +73,8 @@ const create = (name, options) => {
             });
         };
         $.end = () => {
-            if (span_obj.end)
-                return void 0;
-            span_obj.end = Date.now();
+            if (span_obj.end == null)
+                span_obj.end = Date.now();
         };
         return $;
     };
@@ -94,7 +84,8 @@ const create = (name, options) => {
     const endRoot = root.end.bind(root);
     root.end = async () => {
         endRoot();
-        await Promise.all(promises);
+        if (PROMISES.has(root))
+            await Promise.all(PROMISES.get(root));
         return options.exporter(spans, {
             ...(options.context || {}),
             ...sdk_object,
@@ -103,4 +94,4 @@ const create = (name, options) => {
     return root;
 };
 
-export { create };
+export { ADD_PROMISE, PROMISES, create };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rian",
-	"version": "0.0.4",
+	"version": "0.1.1",
 	"description": "Effective tracing for the edge and origins",
 	"keywords": [
 		"opentelemetry",
@@ -37,6 +37,10 @@
 			"import": "./exporter.zipkin.mjs",
 			"require": "./exporter.zipkin.js"
 		},
+		"./utils": {
+			"import": "./utils.mjs",
+			"require": "./utils.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"main": "./index.js",

package/utils.d.ts

@@ -0,0 +1,46 @@
+import { Scope } from 'rian';
+
+declare type MeasureFn = ((...args: [...args: any[]]) => any) | ((...args: [...args: any[], scope: Scope]) => any);
+declare type RealMeasureFnParams<T extends unknown[]> = T extends [] ? [] : T extends [...rest: infer U, scope: Scope] ? U : T;
+/**
+ * With a passed function — will start a span, and run the function, when the function finishes
+ * the span finishes.
+ *
+ * The measure method will return whatever the function is, so if it's a promise, it returns a
+ * promise and so on. Any error is caught and re thrown, and automatically tracked in the
+ * context under the `error` property.
+ *
+ * All promises are tracked, and awaited on a `tracer.end`.
+ *
+ * @example
+ *
+ * ```text
+ * const data = await measure(scope, 'name', get_data, 'user_id_123');
+ *        ^                    ^      ^       ^          ^
+ *        |                    |      |       |          |
+ *        |                    |      |       |          the first argument to get_data
+ *        |                    |      |       function to be called
+ *        |                    |      the name of the sub scope
+ *        |                    |
+ *        |                    the parent scope
+ *         return value from get_data
+ * ```
+ */
+declare const measure: <Fn extends MeasureFn>(scope: Scope, name: string, fn: Fn, ...args: RealMeasureFnParams<Parameters<Fn>>) => ReturnType<Fn>;
+/**
+ * Wraps any function with a measured scoped function. Useful for when defer function execution
+ * till a later time.
+ *
+ * @example
+ *
+ * ```js
+ * const wrapped = wrap(scope, "run something", my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+declare const wrap: <Fn extends MeasureFn>(scope: Scope, name: string, fn: Fn) => Fn;
+
+export { MeasureFn, measure, wrap };

package/utils.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const rian = require('rian');
+
+const set_error = (scope, error) => {
+    scope.set_context({
+        error,
+    });
+};
+/**
+ * @internal
+ */
+const measureFn = (scope, fn, ...args) => {
+    try {
+        var r = fn(...args, scope), is_promise = r instanceof Promise;
+        if (is_promise && rian.PROMISES.has(scope))
+            rian.ADD_PROMISE(scope, r
+                .catch((e) => void set_error(scope, e))
+                .finally(() => scope.end()));
+        return r;
+    }
+    catch (e) {
+        if (e instanceof Error)
+            set_error(scope, e);
+        throw e;
+    }
+    finally {
+        // @ts-expect-error TS2454
+        if (is_promise !== true)
+            scope.end();
+    }
+};
+/**
+ * With a passed function — will start a span, and run the function, when the function finishes
+ * the span finishes.
+ *
+ * The measure method will return whatever the function is, so if it's a promise, it returns a
+ * promise and so on. Any error is caught and re thrown, and automatically tracked in the
+ * context under the `error` property.
+ *
+ * All promises are tracked, and awaited on a `tracer.end`.
+ *
+ * @example
+ *
+ * ```text
+ * const data = await measure(scope, 'name', get_data, 'user_id_123');
+ *        ^                    ^      ^       ^          ^
+ *        |                    |      |       |          |
+ *        |                    |      |       |          the first argument to get_data
+ *        |                    |      |       function to be called
+ *        |                    |      the name of the sub scope
+ *        |                    |
+ *        |                    the parent scope
+ *         return value from get_data
+ * ```
+ */
+const measure = (scope, name, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope.fork(name), fn, ...args);
+/**
+ * Wraps any function with a measured scoped function. Useful for when defer function execution
+ * till a later time.
+ *
+ * @example
+ *
+ * ```js
+ * const wrapped = wrap(scope, "run something", my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+const wrap = (scope, name, fn) => function () {
+    return measureFn(scope.fork(name), fn, ...arguments);
+};
+
+exports.measure = measure;
+exports.measureFn = measureFn;
+exports.wrap = wrap;

package/utils.mjs

@@ -0,0 +1,75 @@
+import { PROMISES, ADD_PROMISE } from 'rian';
+
+const set_error = (scope, error) => {
+    scope.set_context({
+        error,
+    });
+};
+/**
+ * @internal
+ */
+const measureFn = (scope, fn, ...args) => {
+    try {
+        var r = fn(...args, scope), is_promise = r instanceof Promise;
+        if (is_promise && PROMISES.has(scope))
+            ADD_PROMISE(scope, r
+                .catch((e) => void set_error(scope, e))
+                .finally(() => scope.end()));
+        return r;
+    }
+    catch (e) {
+        if (e instanceof Error)
+            set_error(scope, e);
+        throw e;
+    }
+    finally {
+        // @ts-expect-error TS2454
+        if (is_promise !== true)
+            scope.end();
+    }
+};
+/**
+ * With a passed function — will start a span, and run the function, when the function finishes
+ * the span finishes.
+ *
+ * The measure method will return whatever the function is, so if it's a promise, it returns a
+ * promise and so on. Any error is caught and re thrown, and automatically tracked in the
+ * context under the `error` property.
+ *
+ * All promises are tracked, and awaited on a `tracer.end`.
+ *
+ * @example
+ *
+ * ```text
+ * const data = await measure(scope, 'name', get_data, 'user_id_123');
+ *        ^                    ^      ^       ^          ^
+ *        |                    |      |       |          |
+ *        |                    |      |       |          the first argument to get_data
+ *        |                    |      |       function to be called
+ *        |                    |      the name of the sub scope
+ *        |                    |
+ *        |                    the parent scope
+ *         return value from get_data
+ * ```
+ */
+const measure = (scope, name, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope.fork(name), fn, ...args);
+/**
+ * Wraps any function with a measured scoped function. Useful for when defer function execution
+ * till a later time.
+ *
+ * @example
+ *
+ * ```js
+ * const wrapped = wrap(scope, "run something", my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+const wrap = (scope, name, fn) => function () {
+    return measureFn(scope.fork(name), fn, ...arguments);
+};
+
+export { measure, measureFn, wrap };