rian 0.3.0-next.9 → 0.3.1

package/readme.md

@@ -6,9 +6,6 @@
 
 <p><code>npm add rian</code> doesn't overcomplicate tracing</p>
 <span>
-<a href="https://github.com/maraisr/rian/actions/workflows/ci.yml">
-	<img src="https://github.com/maraisr/rian/actions/workflows/ci.yml/badge.svg"/>
-</a>
 <a href="https://npm-stat.com/charts.html?package=rian">
 	<img src="https://badgen.net/npm/dw/rian?labelColor=black&color=black&cache=600" alt="downloads"/>
 </a>
@@ -26,84 +23,136 @@
 
 ## ⚡ Features
 
-- 🤔 **Familiar** — looks very much like OpenTracing.
+- 🤔 **Familiar** — looks very much like opentelemetry.
 
-- ✅ **Simple** — `create` a tracer, and `report()`, done.
+- ✅ **Simple** — `configure()` an environment, create a `tracer()`, `report()` and done.
 
 - 🏎 **Performant** — check the [benchmarks](#-benchmark).
 
-- 🪶 **Lightweight** — a mere 1Kb and next to no [dependencies](https://npm.anvaka.com/#/view/2d/rian/).
+- 🪶 **Lightweight** — a mere 1KB and next to no [dependencies](https://npm.anvaka.com/#/view/2d/rian/).
 
 ## 🚀 Usage
 
-> Visit [/examples](/examples) for more info!
+> Visit [/examples](/examples) for more!
 
 ```ts
-import { configure, create, report } from 'rian';
-import { measure } from 'rian/utils';
+import { configure, tracer, report } from 'rian';
 import { exporter } from 'rian/exporter.otel.http';
 
-// ~> Where to send the spans.
-const otel_endpoint = exporter((payload) =>
-  fetch('/traces/otlp', {
-    method: 'POST',
-    body: JSON.stringify(payload),
-  }),
-);
-
-// ~> Configure the environment
-
+// ~> configure the environment, all tracers will inherit this
 configure('my-service' {
   'service.version': 'DEV'
 });
 
-// ~> Create a tracer — typically "per request" or "per operation"
+// ~> create a tracer — typically "per request" or "per operation".
 const trace = tracer('request');
 
-// Let us trace
+function handler(req) {
+  // ~> start a span
+  return trace.span(`${req.method} ${req.path}`)(async (s) => {
+    // set some fields on this span's context
+    s.set_context({ user_id: req.params.user_id });
 
-const req = trace.span('GET ~> /data');
+    // ~> span again for `db::read`
+    const data = await s.span('db::read')(() => db_execute('SELECT * FROM users'));
 
-req.set_context({
-  user: request_context.user_id,
-});
+    // ~> maybe have some manual spanning
+    const processing_span = s.span('process records');
 
-// ~> Wrap any method and be timed 🕺🏻
-const data = await measure(req.span('db::read'), get_data);
+    for (let row of data) {
+      processing_span.add_event('doing stuff', { id: row.id });
+      do_stuff(row);
+    }
 
-// ~> Maybe have some in-flow spanning
-const span = req.span('process records');
+    // don't forget to end
+    processing_span.end();
 
-for (let row of data) {
-  span.add_event('doing stuff', { id: row.id });
-  do_stuff(row);
+    return reply(200, { data });
+  });
 }
 
-span.end();
-
-req.end();
+const otel_exporter = exporter((payload) =>
+  fetch('/traces/otlp', {
+    method: 'POST',
+    body: JSON.stringify(payload),
+  }),
+);
 
-// ~> And finally let's export — will also end the root span.
-await report(otel_endpoint);
+http.listen((req, executionCtx) => {
+  // ~> report all the spans once the response is sent
+  executionCtx.defer(() => report(otel_exporter));
+  return handler(req);
+});
 
 /*
 And we end up with something like this in our reporting tool:
 
-[ GET ~> /data .................................... (1.2ms) ]
-   [ db::read .... (0.5ms) ]
-                           [ process records .... (0.5ms) ]
+[ GET /data .................,,...................... (1.2ms) ] { request }
+   [ db::read .... (0.5ms) ] [ process records .... (0.5ms) ]
+   ^                           ^             ^            ^
+   { user_id }                 ev { id: 1 }  |            |
+                                             ev { id: 2 } |
+                                                          ev { id: 3 }
  */
 ```
 
+You only need to `report` in your application once somewhere. All spans are collected into the same "bucket".
+
 ## 🔎 API
 
 #### Module: [`rian`](./packages/rian/src/index.ts)
 
 The main and _default_ module responsible for creating and provisioning spans.
 
-> 💡 Note ~> when providing span context values, please stick to
-> [Semantic Conventions](https://github.com/opentracing/specification/blob/master/semantic_conventions.md), but won't be
-> enforced.
+> 💡 Note ~> when providing span context values, you can use
+> [Semantic Conventions](https://opentelemetry.io/docs/reference/specification/trace/semantic_conventions/), but won't
+> be enforced.
+
+#### Module: [`rian/async`](./packages/rian/src/async.ts)
+
+A module that utilizes the `async_hooks` API to provide a `tracer` and `spans` that can be used where the current span
+isn't accessible.
+
+> 💡 Note ~> this module should be used mutually exclusively with the main `rian` module.
+
+<detials>
+
+<summary>Example</summary>
+
+```ts
+import { configure, tracer, span, currentSpan, report } from 'rian/async';
+import { exporter } from 'rian/exporter.otel.http';
+
+function handler(req) {
+  return span(`${req.method} ${req.path}`)(async () => {
+    const s = currentSpan();
+
+    s.set_context({ user_id: req.params.user_id });
+
+    const data = await s.span('db::read')(() => db_execute('SELECT * FROM users'));
+
+    const processing_span = s.span('process records');
+
+    for (let row of data) {
+      processing_span.add_event('doing stuff', { id: row.id });
+      do_stuff(row);
+    }
+
+    processing_span.end();
+
+    return reply(200, { data });
+  });
+}
+
+const httpTrace = tracer('http');
+
+http.listen((req, executionCtx) => {
+  executionCtx.defer(() => report(exporter));
+  return httpTrace(() => handler(req));
+});
+```
+
+</details>
 
 #### Module: [`rian/exporter.zipkin`](./packages/rian/src/exporter.zipkin.ts)
 
@@ -118,7 +167,7 @@ Implements the OpenTelemetry protocol for use with http transports.
 <details><summary>NewRelic</summary>
 
 ```ts
-import { tracer, report } from 'rian';
+import { configure, tracer, report } from 'rian';
 import { exporter } from 'rian/exporter.zipkin';
 
 const newrelic = exporter((payload) =>
@@ -134,7 +183,9 @@ const newrelic = exporter((payload) =>
   }),
 );
 
-const tracer = tracer('my-service');
+configure('my-service');
+
+const tracer = tracer('app');
 
 await report(newrelic);
 ```
@@ -143,14 +194,14 @@ await report(newrelic);
 
 </details>
 
-<details><summary>LightStep</summary>
+<details><summary>Lightstep</summary>
 
 ```ts
-import { tracer, report } from 'rian';
+import { configure, tracer, report } from 'rian';
 import { exporter } from 'rian/exporter.otel.http';
 
 const lightstep = exporter((payload) =>
-  fetch('https://ingest.lightstep.com/traces/otlp/v0.6', {
+  fetch('https://ingest.lightstep.com/traces/otlp/v0.9', {
     method: 'POST',
     headers: {
       'lightstep-access-token': '<your api key>',
@@ -160,7 +211,9 @@ const lightstep = exporter((payload) =>
   }),
 );
 
-const tracer = tracer('my-service');
+configure('my-service');
+
+const tracer = tracer('app');
 
 await report(lightstep);
 ```
@@ -171,34 +224,23 @@ await report(lightstep);
 
 ## 🤔 Motivation
 
-Firstly, what is `rian`? _trace_ in Irish is `rian`.
-
-In efforts to be better observant citizens, we generally reach for the — NewRelic, LightStep, DataDog's. Which, and in
-no offence to them, is bloated and slow! Where they more often than not do way too much or and relatively speaking, ship
-useless traces. Which ramp up your bill — see... every span you trace, costs.
-
-And here we are, introducing **rian** — a lightweight, fast effective tracer. Inspired by the giants in the industry,
-OpenTracing and OpenTelemetry.
-
-You might have not heard of those before — and that is okay. It means the design goals from OpenTelemetry or OpenTracing
-has been met. They are frameworks built to abstract the telemetry part from vendors. So folk like NewRelic can wrap
-their layers on top of open telemetry — and have libraries instrument theirs without knowing about the vendor. Which
-allows consumers to ship those spans to the vendor of their choosing. OpenTracing has a very similar design goal, so
-please do go checkout their documentation's, to help decide.
+To clarify, `rian` is the Irish word for "trace".
 
-Rian does not intend to align or compete with them. rian's intent is to be used to instrument your application and
-**only** your application. Rian is primed in that critical business paths — where you don't care " which handlers
-MongoDB ran", or how many network calls your ORM made. Cardinality will destroy you. Although rian can scale to support
-those as well. But the reality is; there are profiler tools far more capable — "right tool for the job".
+In our efforts to be observant citizens, we often rely on tools such as NewRelic, Lightstep, and Datadog. However, these
+tools can be bloated and slow, often performing too many unnecessary tasks and driving up costs, as every span costs.
 
-Rian is simply a tracer you can use to see what your application is doing, have better insight into why something failed
-and stitch it with your logs. It starts by capturing a [`w3c trace-context`](https://www.w3.org/TR/trace-context/),
-tracing some business steps. "inbound request /data", "getting data", "sending email", or as granular as you'd like. And
-have that forwarded onto all sub-services.
+This is where rian comes in as a lightweight, fast, and effective tracer inspired by industry giants OpenTracing and
+OpenTelemetry. These frameworks were designed to abstract the telemetry part from vendors, allowing libraries to be
+instrumented without needing to know about the vendor.
 
-You see, the primary design goal is targeted at edge or service workers — where lean quick tracers is favoured.
+Rian does not intend to align or compete with them, slightly different goals. Rian aims to be used exclusively for
+instrumenting your application, particularly critical business paths. While rian can scale to support more complex
+constructs, there are profiler tools that are better suited for those jobs. Rian's primary design goal is to provide
+better insights into your application's behavior, particularly for edge or service workers where a lean tracer is
+favored.
 
-Rian is still in active development, but ready for production!
+Rian does not by design handle injecting [`w3c trace-context`](https://www.w3.org/TR/trace-context/), or
+[propagating baggage](https://www.w3.org/TR/baggage/). But we do expose api's for achieving this.
 
 ## 💨 Benchmark
 
@@ -207,19 +249,23 @@ Rian is still in active development, but ready for production!
 ```
 Validation :: single span
 ✔ rian
+✔ rian/async
 ✔ opentelemetry
 
 Benchmark :: single span
-  rian                   x 385,085 ops/sec ±4.26% (85 runs sampled)
-  opentelemetry          x 205,004 ops/sec ±11.99% (65 runs sampled)
+  rian                   x 277,283 ops/sec ±3.57% (90 runs sampled)
+  rian/async             x 279,525 ops/sec ±2.33% (91 runs sampled)
+  opentelemetry          x 155,019 ops/sec ±13.13% (70 runs sampled)
 
 Validation :: child span
 ✔ rian
+✔ rian/async
 ✔ opentelemetry
 
 Benchmark :: child span
-  rian                   x 206,736 ops/sec ±6.37% (86 runs sampled)
-  opentelemetry          x 128,298 ops/sec ±14.82% (68 runs sampled)
+  rian                   x 146,793 ops/sec ±3.38% (87 runs sampled)
+  rian/async             x 180,488 ops/sec ±1.64% (92 runs sampled)
+  opentelemetry          x 102,541 ops/sec ±9.77% (73 runs sampled)
 ```
 
 > And please... I know these results are anything but the full story. But it's a number and point on comparison.
@@ -231,5 +277,5 @@ MIT © [Marais Rossouw](https://marais.io)
 ##### Disclaimer
 
 <sup>- NewRelic is a registered trademark of https://newrelic.com/ and not affiliated with this project.</sup><br />
-<sup>- DataDog is a registered trademark of https://www.datadoghq.com/ and not affiliated with this project.</sup><br />
-<sup>- LightStep is a registered trademark of https://lightstep.com/ and not affiliated with this project.</sup>
+<sup>- Datadog is a registered trademark of https://www.datadoghq.com/ and not affiliated with this project.</sup><br />
+<sup>- Lightstep is a registered trademark of https://lightstep.com/ and not affiliated with this project.</sup>

package/utils.d.ts

@@ -1,66 +1,25 @@
 import type { Scope } from 'rian';
 
-export type MeasureFn =
-	| ((...args: [...args: any[]]) => any)
-	| ((...args: [...args: any[], scope: Scope]) => any);
-
 /**
- * With a passed function — will start a span, and run the function, when the function finishes
- * the span finishes.
+ * With a passed function, `measure` will run the function and once finishes, will end the span.
  *
  * 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`.
+ * All promises are tracked, and awaited on a `report`.
  *
- * @example
- *
- * ```text
- * const data = await measure(scope, get_data, 'user_id_123');
- *       ^                    ^     ^          ^
- *       |                    |     |          |
- *       |                    |     |          the first argument to get_data
- *       |                    |     |
- *       |                    |     function to be called
- *       |                    |
- *       |                    the parent scope
- *       return value from get_data
- * ```
- */
-export const measure: <Fn extends MeasureFn>(
-	scope: Scope,
-	fn: Fn, // TODO: fn doesnt see scope correctly
-	...args: RealMeasureFnParams<Parameters<Fn>>
-) => ReturnType<Fn>;
-
-/**
- * Wraps any function with a measured scoped function. Useful for when defer function execution
- * till a later time.
+ * This is a utility method, but is functionally equivalent to `scope.span('name')(fn)`.
  *
  * @example
  *
- * ```js
- * const wrapped = wrap(scope, "run something", my_function);
- *
- * // ... lots of things, where the access to `scope` is lost.
- *
- * wrapped();
+ * ```text
+ * const data = await measure(scope, get_data);
+ * // or with arguments:
+ * const data = await measure(scope, () => get_data('foo', 'bar'));
  * ```
  */
-export const wrap: <Fn extends MeasureFn>(
+export function measure<Fn extends (scope: Scope) => any>(
 	scope: Scope,
-	fn: Fn, // TODO: fn doesnt see scope correctly
-) => Fn;
-
-// ==> internals
-
-/** @internal */
-export type RealMeasureFnParams<T extends unknown[]> = T extends []
-	? []
-	: T extends [...rest: infer U, scope: Scope]
-	? U
-	: T;
-
-/** @internal */
-export const measureFn: (scope: Scope, fn: any, ...args: any[]) => any;
+	fn: Fn,
+): ReturnType<Fn>;

package/utils.js

@@ -1,26 +1 @@
-// src/utils.ts
-var measureFn = (scope, fn, ...args) => {
-  try {
-    var r = fn(...args, scope), is_promise = r instanceof Promise;
-    return is_promise && scope.__add_promise(
-      r.catch(
-        (e) => void scope.set_context({
-          error: e
-        })
-      ).finally(() => scope.end())
-    ), r;
-  } catch (e) {
-    throw e instanceof Error && scope.set_context({
-      error: e
-    }), e;
-  } finally {
-    is_promise !== !0 && scope.end();
-  }
-}, measure = (scope, fn, ...args) => measureFn(scope, fn, ...args), wrap = (scope, fn) => function() {
-  return measureFn(scope, fn, ...arguments);
-};
-
-
-exports.measure = measure;
-exports.measureFn = measureFn;
-exports.wrap = wrap;
+function r(r,t){try{var e=t(r),n=e instanceof Promise;return n&&r.__add_promise(e.catch((t=>{r.set_context({error:t})})).finally((()=>r.end()))),e}catch(t){throw t instanceof Error&&r.set_context({error:t}),t}finally{!0!==n&&r.end()}}exports.measure=r;

package/utils.mjs

@@ -1,26 +1 @@
-// src/utils.ts
-var measureFn = (scope, fn, ...args) => {
-  try {
-    var r = fn(...args, scope), is_promise = r instanceof Promise;
-    return is_promise && scope.__add_promise(
-      r.catch(
-        (e) => void scope.set_context({
-          error: e
-        })
-      ).finally(() => scope.end())
-    ), r;
-  } catch (e) {
-    throw e instanceof Error && scope.set_context({
-      error: e
-    }), e;
-  } finally {
-    is_promise !== !0 && scope.end();
-  }
-}, measure = (scope, fn, ...args) => measureFn(scope, fn, ...args), wrap = (scope, fn) => function() {
-  return measureFn(scope, fn, ...arguments);
-};
-export {
-  measure,
-  measureFn,
-  wrap
-};
+function r(r,t){try{var e=t(r),n=e instanceof Promise;return n&&r.__add_promise(e.catch((t=>{r.set_context({error:t})})).finally((()=>r.end()))),e}catch(t){throw t instanceof Error&&r.set_context({error:t}),t}finally{!0!==n&&r.end()}}export{r as measure};

package/exporter.otel.http/index.d.ts

@@ -1,3 +0,0 @@
-import type { Exporter } from 'rian';
-
-export const exporter: (request: (payload: any) => any) => Exporter;

package/exporter.otel.http/index.js

@@ -1 +0,0 @@
-const { name:e, version:t } = require('rian/package.json');var r=e=>{let t=typeof e,n={};return"string"===t?n.stringValue=e:"number"===t?Number.isInteger(e)?n.intValue=e:n.doubleValue=e:"boolean"===t?n.boolValue=e:Array.isArray(e)?n.arrayValue={values:e.map((e=>r(e)))}:e&&(n.kvlistValue={values:a(e)}),n},a=e=>{let t=[];for(let a of Object.keys(e))t.push({key:a,value:r(e[a])});return t},n=e=>{switch(e){default:case"INTERNAL":return 1;case"SERVER":return 2;case"CLIENT":return 3;case"PRODUCER":return 4;case"CONSUMER":return 5}},s=r=>(s,i)=>{let u=[];for(let e of s){let t,{kind:r,error:s,...i}=e.context;s&&(t={code:2},"message"in s&&(t.message=s.message)),u.push({traceId:e.id.trace_id,spanId:e.id.parent_id,parentSpanId:e.parent?.parent_id,name:e.name,kind:n(r||"INTERNAL"),startTimeUnixNano:1e6*e.start,endTimeUnixNano:e.end?1e6*e.end:void 0,droppedAttributesCount:0,droppedEventsCount:0,droppedLinksCount:0,attributes:a(i),status:t||{code:0},events:e.events.map((e=>({name:e.name,attributes:a(e.attributes),droppedAttributesCount:0,timeUnixNano:1e6*e.timestamp})))})}return r({resourceSpans:[{resource:{attributes:a(i),droppedAttributesCount:0},instrumentationLibrarySpans:[{instrumentationLibrary:{name:e,version:t},spans:u}]}]})};exports.exporter=s;

package/exporter.otel.http/index.mjs

@@ -1 +0,0 @@
-import{name as e,version as t}from"rian/package.json";var r=e=>{let t=typeof e,n={};return"string"===t?n.stringValue=e:"number"===t?Number.isInteger(e)?n.intValue=e:n.doubleValue=e:"boolean"===t?n.boolValue=e:Array.isArray(e)?n.arrayValue={values:e.map((e=>r(e)))}:e&&(n.kvlistValue={values:a(e)}),n},a=e=>{let t=[];for(let a of Object.keys(e))t.push({key:a,value:r(e[a])});return t},n=e=>{switch(e){default:case"INTERNAL":return 1;case"SERVER":return 2;case"CLIENT":return 3;case"PRODUCER":return 4;case"CONSUMER":return 5}},s=r=>(s,i)=>{let u=[];for(let e of s){let t,{kind:r,error:s,...i}=e.context;s&&(t={code:2},"message"in s&&(t.message=s.message)),u.push({traceId:e.id.trace_id,spanId:e.id.parent_id,parentSpanId:e.parent?.parent_id,name:e.name,kind:n(r||"INTERNAL"),startTimeUnixNano:1e6*e.start,endTimeUnixNano:e.end?1e6*e.end:void 0,droppedAttributesCount:0,droppedEventsCount:0,droppedLinksCount:0,attributes:a(i),status:t||{code:0},events:e.events.map((e=>({name:e.name,attributes:a(e.attributes),droppedAttributesCount:0,timeUnixNano:1e6*e.timestamp})))})}return r({resourceSpans:[{resource:{attributes:a(i),droppedAttributesCount:0},instrumentationLibrarySpans:[{instrumentationLibrary:{name:e,version:t},spans:u}]}]})};export{s as exporter};

package/exporter.zipkin/index.d.ts

@@ -1,3 +0,0 @@
-import type { Exporter } from 'rian';
-
-export const exporter: (request: (payload: any) => any) => Exporter;

package/exporter.zipkin/index.js

@@ -1 +0,0 @@
-const { flattie:e } = require('flattie');var t=t=>(a,n)=>{let r=[];for(let t of a){let{kind:a,error:i,...s}=t.context;i&&(s.error=!("message"in i)||{name:i.name,message:i.message,stack:i.stack}),r.push({id:t.id.parent_id,traceId:t.id.trace_id,parentId:t.parent?t.parent.parent_id:void 0,name:t.name,kind:"INTERNAL"===a?void 0:a,timestamp:1e3*t.start,duration:t.end?1e3*(t.end-t.start):void 0,localEndpoint:n.localEndpoint||{serviceName:s["service.name"]},tags:e({...n,...s},".",!0),annotations:t.events.map((e=>({value:`${e.name} :: ${JSON.stringify(e.attributes)}`,timestamp:1e3*e.timestamp})))})}return t(r)};exports.exporter=t;

package/exporter.zipkin/index.mjs

@@ -1 +0,0 @@
-import{flattie as e}from"flattie";var t=t=>(a,n)=>{let r=[];for(let t of a){let{kind:a,error:i,...s}=t.context;i&&(s.error=!("message"in i)||{name:i.name,message:i.message,stack:i.stack}),r.push({id:t.id.parent_id,traceId:t.id.trace_id,parentId:t.parent?t.parent.parent_id:void 0,name:t.name,kind:"INTERNAL"===a?void 0:a,timestamp:1e3*t.start,duration:t.end?1e3*(t.end-t.start):void 0,localEndpoint:n.localEndpoint||{serviceName:s["service.name"]},tags:e({...n,...s},".",!0),annotations:t.events.map((e=>({value:`${e.name} :: ${JSON.stringify(e.attributes)}`,timestamp:1e3*e.timestamp})))})}return t(r)};export{t as exporter};

package/utils/index.d.ts

@@ -1,68 +0,0 @@
-import type { Scope } from 'rian';
-
-export type MeasureFn =
-	| ((...args: [...args: any[]]) => any)
-	| ((...args: [...args: any[], scope: Scope]) => any);
-
-/**
- * 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
- * ```
- */
-export const measure: <Fn extends MeasureFn>(
-	scope: Scope,
-	name: string,
-	fn: Fn, // TODO: fn doesnt see scope correctly
-	...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();
- * ```
- */
-export const wrap: <Fn extends MeasureFn>(
-	scope: Scope,
-	name: string,
-	fn: Fn, // TODO: fn doesnt see scope correctly
-) => Fn;
-
-// ==> internals
-
-/** @internal */
-export type RealMeasureFnParams<T extends unknown[]> = T extends []
-	? []
-	: T extends [...rest: infer U, scope: Scope]
-	? U
-	: T;
-
-/** @internal */
-export const measureFn: (scope: Scope, fn: any, ...args: any[]) => any;

package/utils/index.js

@@ -1 +0,0 @@
-var r=(r,t,...e)=>{try{var n=t(...e,r),o=n instanceof Promise;return o&&r.__add_promise(n.catch((t=>{r.set_context({error:t})})).finally((()=>r.end()))),n}catch(t){throw t instanceof Error&&r.set_context({error:t}),t}finally{!0!==o&&r.end()}},t=(t,e,n,...o)=>r(t.fork(e),n,...o),e=(t,e,n)=>function(){return r(t.fork(e),n,...arguments)};exports.measure=t;exports.measureFn=r;exports.wrap=e;

package/utils/index.mjs

@@ -1 +0,0 @@
-var r=(r,t,...e)=>{try{var n=t(...e,r),o=n instanceof Promise;return o&&r.__add_promise(n.catch((t=>{r.set_context({error:t})})).finally((()=>r.end()))),n}catch(t){throw t instanceof Error&&r.set_context({error:t}),t}finally{!0!==o&&r.end()}},t=(t,e,n,...o)=>r(t.fork(e),n,...o),e=(t,e,n)=>function(){return r(t.fork(e),n,...arguments)};export{t as measure,r as measureFn,e as wrap};