rian 0.0.5 → 0.1.0

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.

package/index.js

@@ -2,6 +2,7 @@
 
 const package_json = require('rian/package.json');
 const tctx = require('tctx');
+const rian = require('rian');
 
 function _interopNamespace(e) {
 	if (e && e.__esModule) return e;
@@ -28,12 +29,11 @@ const set_error = (scope, error) => {
         error,
     });
 };
-const measure = (fn, // TODO: fn doesnt see scope correctly
-scope, promises, ...args) => {
+const measureFn = (scope, fn, ...args) => {
     try {
         var r = fn(...args, scope), is_promise = r instanceof Promise;
-        if (is_promise)
-            promises.push(r
+        if (is_promise && rian.PROMISES.has(scope))
+            rian.ADD_PROMISE(scope, r
                 .catch((e) => void set_error(scope, e))
                 .finally(() => scope.end()));
         return r;
@@ -47,8 +47,44 @@ scope, promises, ...args) => {
             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, get_data, 'user_id_123');
+ *        ^                           ^        ^
+ *        |                           |        |
+ *        |                           |        the first argument to get_data
+ *        |                           function to be called
+ *        return value from get_data
+ * ```
+ */
+const measure = (scope, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope, fn, ...args);
 
 // ==> 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,7 +106,6 @@ 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) => {
@@ -90,10 +125,9 @@ const create = (name, options) => {
         };
         if (should_sample)
             spans.add(span_obj);
-        const $ = (cb) => measure(cb, $, promises);
+        const $ = (cb) => measure($, cb);
         $.traceparent = id;
         $.fork = (name) => span(name, id);
-        $.measure = (name, cb, ...args) => measure(cb, span(name, id), promises, ...args);
         $.set_context = (ctx) => {
             if (typeof ctx === 'function')
                 return void (span_obj.context = ctx(span_obj.context));
@@ -119,8 +153,8 @@ const create = (name, options) => {
     const endRoot = root.end.bind(root);
     root.end = async () => {
         endRoot();
-        if (promises.length)
-            await Promise.all(promises);
+        if (PROMISES.has(root))
+            await Promise.all(PROMISES.get(root));
         return options.exporter(spans, {
             ...(options.context || {}),
             ...sdk_object,
@@ -129,4 +163,6 @@ const create = (name, options) => {
     return root;
 };
 
+exports.ADD_PROMISE = ADD_PROMISE;
+exports.PROMISES = PROMISES;
 exports.create = create;

package/index.mjs

@@ -1,17 +1,17 @@
 import { name, version } from 'rian/package.json';
 import * as tctx from 'tctx';
+import { PROMISES as PROMISES$1, ADD_PROMISE as ADD_PROMISE$1 } from 'rian';
 
 const set_error = (scope, error) => {
     scope.set_context({
         error,
     });
 };
-const measure = (fn, // TODO: fn doesnt see scope correctly
-scope, promises, ...args) => {
+const measureFn = (scope, fn, ...args) => {
     try {
         var r = fn(...args, scope), is_promise = r instanceof Promise;
-        if (is_promise)
-            promises.push(r
+        if (is_promise && PROMISES$1.has(scope))
+            ADD_PROMISE$1(scope, r
                 .catch((e) => void set_error(scope, e))
                 .finally(() => scope.end()));
         return r;
@@ -25,8 +25,44 @@ scope, promises, ...args) => {
             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, get_data, 'user_id_123');
+ *        ^                           ^        ^
+ *        |                           |        |
+ *        |                           |        the first argument to get_data
+ *        |                           function to be called
+ *        return value from get_data
+ * ```
+ */
+const measure = (scope, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope, fn, ...args);
 
 // ==> 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,7 +84,6 @@ 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) => {
@@ -68,10 +103,9 @@ const create = (name, options) => {
         };
         if (should_sample)
             spans.add(span_obj);
-        const $ = (cb) => measure(cb, $, promises);
+        const $ = (cb) => measure($, cb);
         $.traceparent = id;
         $.fork = (name) => span(name, id);
-        $.measure = (name, cb, ...args) => measure(cb, span(name, id), promises, ...args);
         $.set_context = (ctx) => {
             if (typeof ctx === 'function')
                 return void (span_obj.context = ctx(span_obj.context));
@@ -97,8 +131,8 @@ const create = (name, options) => {
     const endRoot = root.end.bind(root);
     root.end = async () => {
         endRoot();
-        if (promises.length)
-            await Promise.all(promises);
+        if (PROMISES.has(root))
+            await Promise.all(PROMISES.get(root));
         return options.exporter(spans, {
             ...(options.context || {}),
             ...sdk_object,
@@ -107,4 +141,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.5",
+	"version": "0.1.0",
 	"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,43 @@
+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, get_data, 'user_id_123');
+ *        ^                           ^        ^
+ *        |                           |        |
+ *        |                           |        the first argument to get_data
+ *        |                           function to be called
+ *        return value from get_data
+ * ```
+ */
+declare const measure: <Fn extends MeasureFn>(scope: Scope, 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, my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+declare const wrap: <Fn extends MeasureFn>(scope: Scope, fn: Fn) => Fn;
+
+export { MeasureFn, measure, wrap };

package/utils.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const rian = require('rian');
+
+const set_error = (scope, error) => {
+    scope.set_context({
+        error,
+    });
+};
+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) {
+        set_error(scope, e);
+        throw e;
+    }
+    finally {
+        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, get_data, 'user_id_123');
+ *        ^                           ^        ^
+ *        |                           |        |
+ *        |                           |        the first argument to get_data
+ *        |                           function to be called
+ *        return value from get_data
+ * ```
+ */
+const measure = (scope, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope, 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, my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+const wrap = (scope, fn) => function () {
+    return measureFn(scope, fn, ...arguments);
+};
+
+exports.measure = measure;
+exports.wrap = wrap;

package/utils.mjs

@@ -0,0 +1,67 @@
+import { PROMISES, ADD_PROMISE } from 'rian';
+
+const set_error = (scope, error) => {
+    scope.set_context({
+        error,
+    });
+};
+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) {
+        set_error(scope, e);
+        throw e;
+    }
+    finally {
+        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, get_data, 'user_id_123');
+ *        ^                           ^        ^
+ *        |                           |        |
+ *        |                           |        the first argument to get_data
+ *        |                           function to be called
+ *        return value from get_data
+ * ```
+ */
+const measure = (scope, fn, // TODO: fn doesnt see scope correctly
+...args) => measureFn(scope, 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, my_function);
+ *
+ * // ... lots of things, where the access to `scope` is lost.
+ *
+ * wrapped();
+ * ```
+ */
+const wrap = (scope, fn) => function () {
+    return measureFn(scope, fn, ...arguments);
+};
+
+export { measure, wrap };