rian 0.0.2-alpha.7 → 0.0.3

package/exporter.otel.http.d.ts

@@ -0,0 +1,5 @@
+import * as rian from 'rian';
+
+declare const exporter: (request: (payload: any) => any) => rian.Exporter;
+
+export { exporter };

package/exporter.otel.http.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const package_json = require('rian/package.json');
+
+const SpanStatusCode_UNSET = 0;
+const SpanStatusCode_ERROR = 2;
+const convert_value_to_anyvalue = (value) => {
+    let type = typeof value, any_value = {};
+    if (type === 'string')
+        any_value.stringValue = value;
+    else if (type === 'number')
+        if (Number.isInteger(value))
+            any_value.intValue = value;
+        else
+            any_value.doubleValue = value;
+    else if (type === 'boolean')
+        any_value.boolValue = value;
+    else if (Array.isArray(value))
+        any_value.arrayValue = {
+            values: value.map((i) => convert_value_to_anyvalue(i)),
+        };
+    else
+        any_value.kvlistValue = { values: convert_object_to_kv(value) };
+    return any_value;
+};
+const convert_object_to_kv = (input) => {
+    const value = [];
+    for (let key of Object.keys(input)) {
+        value.push({
+            key,
+            value: convert_value_to_anyvalue(input[key]),
+        });
+    }
+    return value;
+};
+// https://github.com/open-telemetry/opentelemetry-proto/blob/b43e9b18b76abf3ee040164b55b9c355217151f3/opentelemetry/proto/trace/v1/trace.proto#L127-L155
+const map_kind = (kind) => {
+    switch (kind) {
+        default:
+        case 'INTERNAL': {
+            return 1;
+        }
+        case 'SERVER': {
+            return 2;
+        }
+        case 'CLIENT': {
+            return 3;
+        }
+        case 'PRODUCER': {
+            return 4;
+        }
+        case 'CONSUMER': {
+            return 5;
+        }
+    }
+};
+const exporter = (request) => (spans, context) => {
+    const otel_spans = [];
+    for (let span of spans) {
+        const { kind, error, ...span_ctx } = span.context;
+        let status;
+        if (error) {
+            status = {
+                code: SpanStatusCode_ERROR,
+            };
+            if ('message' in error) {
+                status.message = error.message;
+            }
+        }
+        otel_spans.push({
+            traceId: span.id.trace_id,
+            spanId: span.id.parent_id,
+            parentSpanId: span.parent?.parent_id,
+            name: span.name,
+            kind: map_kind(kind || 'INTERNAL'),
+            startTimeUnixNano: span.start * 1000000,
+            endTimeUnixNano: span.end ? span.end * 1000000 : undefined,
+            droppedAttributesCount: 0,
+            droppedEventsCount: 0,
+            droppedLinksCount: 0,
+            attributes: convert_object_to_kv(span_ctx),
+            status: status || { code: SpanStatusCode_UNSET },
+            events: span.events.map((i) => ({
+                name: i.name,
+                attributes: convert_object_to_kv(i.attributes),
+                droppedAttributesCount: 0,
+                timeUnixNano: i.timestamp * 1000000,
+            })),
+        });
+    }
+    return request({
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: convert_object_to_kv(context),
+                    droppedAttributesCount: 0,
+                },
+                instrumentationLibrarySpans: [
+                    {
+                        instrumentationLibrary: {
+                            name: package_json.name,
+                            version: package_json.version,
+                        },
+                        spans: otel_spans,
+                    },
+                ],
+            },
+        ],
+    });
+};
+
+exports.exporter = exporter;

package/exporter.otel.http.mjs

@@ -0,0 +1,110 @@
+import { name, version } from 'rian/package.json';
+
+const SpanStatusCode_UNSET = 0;
+const SpanStatusCode_ERROR = 2;
+const convert_value_to_anyvalue = (value) => {
+    let type = typeof value, any_value = {};
+    if (type === 'string')
+        any_value.stringValue = value;
+    else if (type === 'number')
+        if (Number.isInteger(value))
+            any_value.intValue = value;
+        else
+            any_value.doubleValue = value;
+    else if (type === 'boolean')
+        any_value.boolValue = value;
+    else if (Array.isArray(value))
+        any_value.arrayValue = {
+            values: value.map((i) => convert_value_to_anyvalue(i)),
+        };
+    else
+        any_value.kvlistValue = { values: convert_object_to_kv(value) };
+    return any_value;
+};
+const convert_object_to_kv = (input) => {
+    const value = [];
+    for (let key of Object.keys(input)) {
+        value.push({
+            key,
+            value: convert_value_to_anyvalue(input[key]),
+        });
+    }
+    return value;
+};
+// https://github.com/open-telemetry/opentelemetry-proto/blob/b43e9b18b76abf3ee040164b55b9c355217151f3/opentelemetry/proto/trace/v1/trace.proto#L127-L155
+const map_kind = (kind) => {
+    switch (kind) {
+        default:
+        case 'INTERNAL': {
+            return 1;
+        }
+        case 'SERVER': {
+            return 2;
+        }
+        case 'CLIENT': {
+            return 3;
+        }
+        case 'PRODUCER': {
+            return 4;
+        }
+        case 'CONSUMER': {
+            return 5;
+        }
+    }
+};
+const exporter = (request) => (spans, context) => {
+    const otel_spans = [];
+    for (let span of spans) {
+        const { kind, error, ...span_ctx } = span.context;
+        let status;
+        if (error) {
+            status = {
+                code: SpanStatusCode_ERROR,
+            };
+            if ('message' in error) {
+                status.message = error.message;
+            }
+        }
+        otel_spans.push({
+            traceId: span.id.trace_id,
+            spanId: span.id.parent_id,
+            parentSpanId: span.parent?.parent_id,
+            name: span.name,
+            kind: map_kind(kind || 'INTERNAL'),
+            startTimeUnixNano: span.start * 1000000,
+            endTimeUnixNano: span.end ? span.end * 1000000 : undefined,
+            droppedAttributesCount: 0,
+            droppedEventsCount: 0,
+            droppedLinksCount: 0,
+            attributes: convert_object_to_kv(span_ctx),
+            status: status || { code: SpanStatusCode_UNSET },
+            events: span.events.map((i) => ({
+                name: i.name,
+                attributes: convert_object_to_kv(i.attributes),
+                droppedAttributesCount: 0,
+                timeUnixNano: i.timestamp * 1000000,
+            })),
+        });
+    }
+    return request({
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: convert_object_to_kv(context),
+                    droppedAttributesCount: 0,
+                },
+                instrumentationLibrarySpans: [
+                    {
+                        instrumentationLibrary: {
+                            name: name,
+                            version: version,
+                        },
+                        spans: otel_spans,
+                    },
+                ],
+            },
+        ],
+    });
+};
+
+export { exporter };

package/exporter.zipkin.d.ts

@@ -0,0 +1,5 @@
+import * as rian from 'rian';
+
+declare const exporter: (request: (payload: any) => any) => rian.Exporter;
+
+export { exporter };

package/exporter.zipkin.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const flattie = require('flattie');
+
+const exporter = (request) => (spans, context) => {
+    const zipkin = [];
+    for (let span of spans) {
+        const { kind, error, ...span_ctx } = span.context;
+        if (error) {
+            if ('message' in error) {
+                span_ctx.error = {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                };
+            }
+            else {
+                span_ctx.error = true;
+            }
+        }
+        zipkin.push({
+            id: span.id.parent_id,
+            traceId: span.id.trace_id,
+            parentId: span.parent ? span.parent.parent_id : undefined,
+            name: span.name,
+            kind: kind === 'INTERNAL' ? undefined : kind,
+            timestamp: span.start * 1000,
+            duration: span.end ? (span.end - span.start) * 1000 : undefined,
+            localEndpoint: context.localEndpoint,
+            tags: flattie.flattie(Object.assign({}, context, span_ctx), '.', true),
+            annotations: span.events.map((i) => ({
+                value: `${i.name} :: ${JSON.stringify(i.attributes)}`,
+                timestamp: i.timestamp * 1000,
+            })),
+        });
+    }
+    return request(zipkin);
+};
+
+exports.exporter = exporter;

package/exporter.zipkin.mjs

@@ -0,0 +1,38 @@
+import { flattie } from 'flattie';
+
+const exporter = (request) => (spans, context) => {
+    const zipkin = [];
+    for (let span of spans) {
+        const { kind, error, ...span_ctx } = span.context;
+        if (error) {
+            if ('message' in error) {
+                span_ctx.error = {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                };
+            }
+            else {
+                span_ctx.error = true;
+            }
+        }
+        zipkin.push({
+            id: span.id.parent_id,
+            traceId: span.id.trace_id,
+            parentId: span.parent ? span.parent.parent_id : undefined,
+            name: span.name,
+            kind: kind === 'INTERNAL' ? undefined : kind,
+            timestamp: span.start * 1000,
+            duration: span.end ? (span.end - span.start) * 1000 : undefined,
+            localEndpoint: context.localEndpoint,
+            tags: flattie(Object.assign({}, context, span_ctx), '.', true),
+            annotations: span.events.map((i) => ({
+                value: `${i.name} :: ${JSON.stringify(i.attributes)}`,
+                timestamp: i.timestamp * 1000,
+            })),
+        });
+    }
+    return request(zipkin);
+};
+
+export { exporter };

package/index.d.ts

@@ -1,35 +1,188 @@
-import { Traceparent } from 'rian/tracecontext';
+import { Traceparent } from 'tctx';
+import { Scope as Scope$1 } from 'rian';
 
-declare type Span = {
+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
+ * {@link Span.name|name}, and a {@link Span.start|start} and {@link Span.end|end} time.
+ *
+ * Each span should be named, not too vague, and not too precise. For example, "resolve_user_ids"
+ * and not "resolver_user_ids[1,2,3]" nor "resolve".
+ *
+ * A span forms part of a wider trace, and can be visualized like:
+ *
+ * ```plain
+ *  [Span A················································(2ms)]
+ *    [Span B·········································(1.7ms)]
+ *       [Span D···············(0.8ms)]  [Span C......(0.6ms)]
+ * ```
+ *
+ * ---
+ *
+ * Spans are aimed to interoperate with
+ * {@link https://github.com/opentracing/specification/blob/master/specification.md|OpenTracing's Spans}, albeit not entirely api compatible — they do share principles.
+ */
+interface Span {
+    /**
+     * A human-readable name for this span. For example the function name, the name of a subtask,
+     * or stage of the larger stack.
+     *
+     * @example
+     * "resolve_user_ids"
+     * "[POST] /api"
+     */
     name: string;
+    /**
+     * A w3c trace context compatible id for this span. Will .toString() into an injectable header.
+     *
+     * @see https://www.w3.org/TR/trace-context/#traceparent-header
+     * @see https://github.com/maraisr/tctx
+     */
     id: Traceparent;
+    /**
+     * Is the id of rhe parent if this is not the parent {@link Span}.
+     *
+     * @see {@link Span.id}
+     */
     parent?: Traceparent;
+    /**
+     * The time represented as a UNIX epoch timestamp in milliseconds when this span was created.
+     * Typically, via
+     * {@link Scope.fork|tracer.fork()}.
+     */
     start: number;
-    end: number;
-    attributes: Attributes;
-};
-declare type Collector = (spans: ReadonlySet<Span>) => any;
-declare type Attributes = {
-    [property: string]: any;
-};
-declare type Options = {
-    collector: Collector;
-    traceparent?: Traceparent;
-};
-declare type OmitScopeParam<T extends unknown[]> = T extends [] ? [] : T extends [infer H, ...infer R] ? H extends Scope ? OmitScopeParam<R> : [H, ...OmitScopeParam<R>] : T;
-interface CallableScope extends Scope {
-    (cb: (scope: Omit<Scope, 'end'>) => void): ReturnType<typeof cb>;
+    /**
+     * The UNIX epoch timestamp in milliseconds when the span ended, or undefined if ending was not
+     * captured during the current trace. Time should then be assumed as current time.
+     */
+    end?: number;
+    /**
+     * An arbitrary context object useful for storing information during a trace.
+     *
+     * Usually following a convention such as `tag.*`, `http.*` or any of the
+     * {@link https://github.com/opentracing/specification/blob/master/semantic_conventions.md|Semantic Conventions outlined by OpenTracing}.
+     *
+     * ### Note!
+     *
+     * There are a few keys with "powers"
+     *
+     * - `kind` when set will coerce into the exports scheme, aka INTERNAL in zipkin will be
+     * `"INTERNAL"`, or `1` in otel
+     * - `error` when set, will be assumed to be an `Error` instance, and thus its `.message` wil
+     * exist as `error.message` in zipkin, and `status: 2` in otel.
+     */
+    context: Context;
+    /**
+     * Events are user-defined timestamped annotations of "events" that happened during the
+     * lifetime of a span. Consisting of a textual message, and optional attributes.
+     *
+     * As a rule-of-thumb use events to attach verbose information about a span, than an entirely
+     * new span.
+     */
+    events: {
+        name: string;
+        timestamp: number;
+        attributes: Context;
+    }[];
 }
 interface Scope {
+    /**
+     * A W3C traceparent. One can .toString() this if you want to cross a network.
+     */
     traceparent: Traceparent;
-    fork(name: string, traceparent?: Traceparent): CallableScope;
-    measure<Fn extends (...args: any[]) => any, Params extends Parameters<Fn>>(name: string, fn: Fn, ...args: OmitScopeParam<Params>): ReturnType<Fn>;
-    set_attributes(attributes: Attributes): void;
+    /**
+     * 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.
+     *
+     * Passing a function will be available to return a new context.
+     */
+    set_context(contextFn: Context | ((context: Context) => Context)): void;
+    /**
+     * Adds a new event to the span. As a rule-of-thumb use events to attach verbose information
+     * about a span, than an entirely new span.
+     */
+    add_event(name: string, attributes?: Record<string, any>): void;
+    /**
+     * Ends the current span — setting its `end` timestamp. Not calling this, will have its `end`
+     * timestamp nulled out — when the tracer ends.
+     */
     end(): void;
 }
-interface Tracer extends Scope {
-    end(): ReturnType<Collector>;
+interface Tracer extends Omit<Scope, 'end'> {
+    end(): ReturnType<Exporter>;
+}
+/**
+ * An exporter is a method called when the parent scope ends, gets given a Set of all spans traced
+ * during this execution.
+ */
+declare type Exporter = (spans: ReadonlySet<Readonly<Span>>, context: Context) => any;
+/**
+ * @borrows {@link Span.context}
+ */
+interface Context {
+    [property: string]: any;
+}
+/**
+ * Should return true when you want to sample the span, this is ran before the span is traced — so
+ * decisions is made preemptively.
+ *
+ * The Span itself will still be included in the {@link Options.exporter|exporter}, and can be
+ * filtered out there.
+ *
+ * Sampling does impact the traceparent, for injection — and is encoded there.
+ */
+declare type Sampler = (name: string, parentId?: Traceparent, context?: Context) => boolean;
+interface Options {
+    /**
+     * @borrows {@link Exporter}
+     */
+    exporter: Exporter;
+    /**
+     * @borrows {@link Sampler}
+     */
+    sampler?: Sampler;
+    context?: Context;
+    /**
+     * A root, or extracted w3c traceparent stringed header.
+     *
+     * If the id is malformed, the {@link create} method will throw an exception. If no root is
+     * provided then one will be created obeying the {@link Options.sampler|sampling} rules.
+     */
+    traceparent?: string;
+}
+interface CallableScope extends Scope {
+    (cb: (scope: Omit<Scope, 'end'>) => void): ReturnType<typeof cb>;
 }
 declare const create: (name: string, options: Options) => Tracer;
 
-export { Attributes, Collector, Options, Scope, Span, Tracer, create };
+export { Context, Exporter, Options, Sampler, Scope, Span, Tracer, create };

package/index.js

@@ -1,75 +1,128 @@
 'use strict';
 
-const tracecontext = require('rian/tracecontext');
+const package_json = require('rian/package.json');
+const tctx = require('tctx');
 
-const measure = (cb, scope, promises) => {
-    const set_error = (error) => {
-        scope.set_attributes({
-            error,
-        });
-    };
+function _interopNamespace(e) {
+	if (e && e.__esModule) return e;
+	const n = Object.create(null);
+	if (e) {
+		for (const k in e) {
+			if (k !== 'default') {
+				const d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		}
+	}
+	n["default"] = e;
+	return n;
+}
+
+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 {
-        const r = cb();
-        if (r instanceof Promise)
-            promises.push(r.catch(set_error).finally(() => scope.end()));
+        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(e);
+        set_error(scope, e);
         throw e;
     }
     finally {
-        scope.end();
+        if (is_promise !== true)
+            scope.end();
     }
 };
+
+// ==> impl
+/**
+ * The default sampler;
+ *
+ * If no parent
+ * ~> sample
+ * if parent was off
+ * ~> never sample
+ * if parent was on
+ * ~> always sample
+ */
+const defaultSampler = (_name, parentId) => {
+    if (!parentId)
+        return true;
+    return tctx__namespace.is_sampled(parentId);
+};
+const sdk_object = {
+    'telemetry.sdk.name': package_json.name,
+    'telemetry.sdk.version': package_json.version,
+};
 const create = (name, options) => {
     const spans = new Set();
     const promises = [];
-    const scope = (name, parent) => {
-        const me = parent ? parent.child() : tracecontext.make_traceparent();
-        const attributes = {};
-        const start = Date.now();
-        let ended = false;
-        const $ = {
-            get traceparent() {
-                return me;
-            },
-            fork(name) {
-                return scope(name, me);
-            },
-            measure(name, cb, ...args) {
-                const scope = this.fork(name);
-                return measure(() => cb(...args, scope), scope, promises);
-            },
-            set_attributes(attr) {
-                Object.assign(attributes, attr);
-            },
-            end() {
-                if (ended)
-                    return void 0;
-                spans.add({
-                    id: me,
-                    parent,
-                    start,
-                    end: Date.now(),
-                    name,
-                    attributes,
-                });
-                ended = true;
-            },
+    const sampler = options.sampler || defaultSampler;
+    const span = (name, parent) => {
+        const should_sample = sampler(name, parent, options.context);
+        const id = parent
+            ? parent.child(should_sample)
+            : tctx__namespace.make(should_sample);
+        const span_obj = {
+            id,
+            parent,
+            start: Date.now(),
+            name,
+            events: [],
+            context: {},
+        };
+        if (should_sample)
+            spans.add(span_obj);
+        const $ = (cb) => measure(cb, $, promises);
+        $.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));
+            Object.assign(span_obj.context, ctx);
         };
-        return Object.setPrototypeOf((cb) => measure(cb, $, promises), $);
+        $.add_event = (name, attributes) => {
+            span_obj.events.push({
+                name,
+                timestamp: Date.now(),
+                attributes: attributes || {},
+            });
+        };
+        $.end = () => {
+            if (span_obj.end)
+                return void 0;
+            span_obj.end = Date.now();
+        };
+        return $;
     };
-    const me = scope(name, typeof options.traceparent === 'string'
-        ? tracecontext.parse_traceparent(options.traceparent)
-        : options.traceparent);
-    const meEnd = me.end.bind(me);
-    me.end = async () => {
+    const root = span(name, typeof options.traceparent === 'string'
+        ? tctx__namespace.parse(options.traceparent)
+        : undefined);
+    const endRoot = root.end.bind(root);
+    root.end = async () => {
+        endRoot();
         await Promise.all(promises);
-        meEnd();
-        return options.collector(spans);
+        return options.exporter(spans, {
+            ...(options.context || {}),
+            ...sdk_object,
+        });
     };
-    return me;
+    return root;
 };
 
 exports.create = create;

package/index.mjs

@@ -1,73 +1,106 @@
-import { parse_traceparent, make_traceparent } from 'rian/tracecontext';
+import { name, version } from 'rian/package.json';
+import * as tctx from 'tctx';
 
-const measure = (cb, scope, promises) => {
-    const set_error = (error) => {
-        scope.set_attributes({
-            error,
-        });
-    };
+const set_error = (scope, error) => {
+    scope.set_context({
+        error,
+    });
+};
+const measure = (fn, // TODO: fn doesnt see scope correctly
+scope, promises, ...args) => {
     try {
-        const r = cb();
-        if (r instanceof Promise)
-            promises.push(r.catch(set_error).finally(() => scope.end()));
+        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(e);
+        set_error(scope, e);
         throw e;
     }
     finally {
-        scope.end();
+        if (is_promise !== true)
+            scope.end();
     }
 };
+
+// ==> impl
+/**
+ * The default sampler;
+ *
+ * If no parent
+ * ~> sample
+ * if parent was off
+ * ~> never sample
+ * if parent was on
+ * ~> always sample
+ */
+const defaultSampler = (_name, parentId) => {
+    if (!parentId)
+        return true;
+    return tctx.is_sampled(parentId);
+};
+const sdk_object = {
+    'telemetry.sdk.name': name,
+    'telemetry.sdk.version': version,
+};
 const create = (name, options) => {
     const spans = new Set();
     const promises = [];
-    const scope = (name, parent) => {
-        const me = parent ? parent.child() : make_traceparent();
-        const attributes = {};
-        const start = Date.now();
-        let ended = false;
-        const $ = {
-            get traceparent() {
-                return me;
-            },
-            fork(name) {
-                return scope(name, me);
-            },
-            measure(name, cb, ...args) {
-                const scope = this.fork(name);
-                return measure(() => cb(...args, scope), scope, promises);
-            },
-            set_attributes(attr) {
-                Object.assign(attributes, attr);
-            },
-            end() {
-                if (ended)
-                    return void 0;
-                spans.add({
-                    id: me,
-                    parent,
-                    start,
-                    end: Date.now(),
-                    name,
-                    attributes,
-                });
-                ended = true;
-            },
+    const sampler = options.sampler || defaultSampler;
+    const span = (name, parent) => {
+        const should_sample = sampler(name, parent, options.context);
+        const id = parent
+            ? parent.child(should_sample)
+            : tctx.make(should_sample);
+        const span_obj = {
+            id,
+            parent,
+            start: Date.now(),
+            name,
+            events: [],
+            context: {},
+        };
+        if (should_sample)
+            spans.add(span_obj);
+        const $ = (cb) => measure(cb, $, promises);
+        $.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));
+            Object.assign(span_obj.context, ctx);
+        };
+        $.add_event = (name, attributes) => {
+            span_obj.events.push({
+                name,
+                timestamp: Date.now(),
+                attributes: attributes || {},
+            });
         };
-        return Object.setPrototypeOf((cb) => measure(cb, $, promises), $);
+        $.end = () => {
+            if (span_obj.end)
+                return void 0;
+            span_obj.end = Date.now();
+        };
+        return $;
     };
-    const me = scope(name, typeof options.traceparent === 'string'
-        ? parse_traceparent(options.traceparent)
-        : options.traceparent);
-    const meEnd = me.end.bind(me);
-    me.end = async () => {
+    const root = span(name, typeof options.traceparent === 'string'
+        ? tctx.parse(options.traceparent)
+        : undefined);
+    const endRoot = root.end.bind(root);
+    root.end = async () => {
+        endRoot();
         await Promise.all(promises);
-        meEnd();
-        return options.collector(spans);
+        return options.exporter(spans, {
+            ...(options.context || {}),
+            ...sdk_object,
+        });
     };
-    return me;
+    return root;
 };
 
 export { create };

package/package.json

@@ -1,9 +1,19 @@
 {
 	"name": "rian",
-	"version": "0.0.2-alpha.7",
-	"description": "A tracer for the edge",
+	"version": "0.0.3",
+	"description": "Effective tracing for the edge and origins",
 	"keywords": [
-		"TODO"
+		"opentelemetry",
+		"trace-context",
+		"opentracing",
+		"traceparent",
+		"measure",
+		"monitor",
+		"observe",
+		"tracing",
+		"zipkin",
+		"tracer",
+		"trace"
 	],
 	"repository": "maraisr/rian",
 	"license": "MIT",
@@ -19,9 +29,13 @@
 			"import": "./index.mjs",
 			"require": "./index.js"
 		},
-		"./tracecontext": {
-			"import": "./tracecontext.mjs",
-			"require": "./tracecontext.js"
+		"./exporter.otel.http": {
+			"import": "./exporter.otel.http.mjs",
+			"require": "./exporter.otel.http.js"
+		},
+		"./exporter.zipkin": {
+			"import": "./exporter.zipkin.mjs",
+			"require": "./exporter.zipkin.js"
 		},
 		"./package.json": "./package.json"
 	},
@@ -34,6 +48,7 @@
 		"*.d.ts"
 	],
 	"dependencies": {
-		"tctx": "^0.0.9"
+		"flattie": "^1.1.0",
+		"tctx": "^0.0.10"
 	}
 }

package/tracecontext.d.ts

@@ -1 +0,0 @@
-export { Traceparent, make as make_traceparent, parse as parse_traceparent } from 'tctx';

package/tracecontext.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const tctx = require('tctx');
-
-
-
-Object.defineProperty(exports, 'make_traceparent', {
-	enumerable: true,
-	get: function () { return tctx.make; }
-});
-Object.defineProperty(exports, 'parse_traceparent', {
-	enumerable: true,
-	get: function () { return tctx.parse; }
-});

package/tracecontext.mjs

@@ -1 +0,0 @@
-export { make as make_traceparent, parse as parse_traceparent } from 'tctx';