rian 0.0.5 → 0.2.1

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

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

package/exporter.otel.http/index.js

@@ -0,0 +1,110 @@
+// src/exporter.otel.http.ts
+const { name:rian_name, version:rian_version } = require('rian/package.json');
+var SpanStatusCode_UNSET = 0;
+var SpanStatusCode_ERROR = 2;
+var 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 if (value)
+    any_value.kvlistValue = { values: convert_object_to_kv(value) };
+  return any_value;
+};
+var 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;
+};
+var 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;
+    }
+  }
+};
+var 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 * 1e6,
+      endTimeUnixNano: span.end ? span.end * 1e6 : void 0,
+      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 * 1e6
+      }))
+    });
+  }
+  return request({
+    resourceSpans: [
+      {
+        resource: {
+          attributes: convert_object_to_kv(context),
+          droppedAttributesCount: 0
+        },
+        instrumentationLibrarySpans: [
+          {
+            instrumentationLibrary: {
+              name: rian_name,
+              version: rian_version
+            },
+            spans: otel_spans
+          }
+        ]
+      }
+    ]
+  });
+};
+
+
+exports.exporter = exporter;

package/exporter.otel.http/index.mjs

@@ -0,0 +1,110 @@
+// src/exporter.otel.http.ts
+import { name as rian_name, version as rian_version } from "rian/package.json";
+var SpanStatusCode_UNSET = 0;
+var SpanStatusCode_ERROR = 2;
+var 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 if (value)
+    any_value.kvlistValue = { values: convert_object_to_kv(value) };
+  return any_value;
+};
+var 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;
+};
+var 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;
+    }
+  }
+};
+var 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 * 1e6,
+      endTimeUnixNano: span.end ? span.end * 1e6 : void 0,
+      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 * 1e6
+      }))
+    });
+  }
+  return request({
+    resourceSpans: [
+      {
+        resource: {
+          attributes: convert_object_to_kv(context),
+          droppedAttributesCount: 0
+        },
+        instrumentationLibrarySpans: [
+          {
+            instrumentationLibrary: {
+              name: rian_name,
+              version: rian_version
+            },
+            spans: otel_spans
+          }
+        ]
+      }
+    ]
+  });
+};
+export {
+  exporter
+};

package/exporter.zipkin/index.d.ts

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

package/exporter.zipkin/index.js

@@ -0,0 +1,43 @@
+// src/exporter.zipkin.ts
+const { flattie } = require('flattie');
+var 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 : void 0,
+      name: span.name,
+      kind: kind === "INTERNAL" ? void 0 : kind,
+      timestamp: span.start * 1e3,
+      duration: span.end ? (span.end - span.start) * 1e3 : void 0,
+      localEndpoint: context.localEndpoint || {
+        serviceName: span_ctx["service.name"]
+      },
+      tags: flattie({
+        ...context,
+        ...span_ctx
+      }, ".", true),
+      annotations: span.events.map((i) => ({
+        value: `${i.name} :: ${JSON.stringify(i.attributes)}`,
+        timestamp: i.timestamp * 1e3
+      }))
+    });
+  }
+  return request(zipkin);
+};
+
+
+exports.exporter = exporter;

package/exporter.zipkin/index.mjs

@@ -0,0 +1,43 @@
+// src/exporter.zipkin.ts
+import { flattie } from "flattie";
+var 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 : void 0,
+      name: span.name,
+      kind: kind === "INTERNAL" ? void 0 : kind,
+      timestamp: span.start * 1e3,
+      duration: span.end ? (span.end - span.start) * 1e3 : void 0,
+      localEndpoint: context.localEndpoint || {
+        serviceName: span_ctx["service.name"]
+      },
+      tags: flattie({
+        ...context,
+        ...span_ctx
+      }, ".", true),
+      annotations: span.events.map((i) => ({
+        value: `${i.name} :: ${JSON.stringify(i.attributes)}`,
+        timestamp: i.timestamp * 1e3
+      }))
+    });
+  }
+  return request(zipkin);
+};
+export {
+  exporter
+};

package/index.d.ts

@@ -1,9 +1,3 @@
-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
  * {@link Span.name|name}, and a {@link Span.start|start} and {@link Span.end|end} time.
@@ -24,134 +18,124 @@ declare type RealMeasureFnParams<T extends unknown[]> = T extends [] ? [] : T ex
  * 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;
-    /**
-     * 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;
-    }[];
+export 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 | undefined;
+
+	/**
+	 * The time represented as a UNIX epoch timestamp in milliseconds when this span was created.
+	 * Typically, via
+	 * {@link Scope.fork|tracer.fork()}.
+	 */
+	start: number;
+
+	/**
+	 * 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;
-    /**
-     * 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;
+
+export interface Scope {
+	/**
+	 * A W3C traceparent. One can .toString() this if you want to cross a network.
+	 */
+	traceparent: Traceparent;
+
+	/**
+	 * Forks the span into a new child span.
+	 */
+	fork(name: string): CallableScope;
+
+	/**
+	 * 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 Omit<Scope, 'end'> {
-    end(): ReturnType<Exporter>;
+
+export 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;
+export type Exporter = (
+	spans: ReadonlySet<Readonly<Span>>,
+	context: Context,
+) => any;
+
 /**
  * @borrows {@link Span.context}
  */
-interface Context {
-    [property: string]: any;
+export 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.
@@ -161,28 +145,45 @@ interface Context {
  *
  * 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 | boolean;
-    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;
+export type Sampler = (
+	name: string,
+	parentId?: Traceparent,
+	context?: Context,
+) => boolean;
+
+export interface Options {
+	/**
+	 * @borrows {@link Exporter}
+	 */
+	exporter: Exporter;
+
+	/**
+	 * @borrows {@link Sampler}
+	 */
+	sampler?: Sampler | boolean;
+
+	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>;
+
+export const create: (name: string, options: Options) => Tracer;
+
+// ==> internals
+
+/** @internal */
+export interface CallableScope extends Scope {
+	(cb: (scope: Omit<Scope, 'end'>) => void): ReturnType<typeof cb>;
 }
-declare const create: (name: string, options: Options) => Tracer;
 
-export { Context, Exporter, Options, Sampler, Scope, Span, Tracer, create };
+/** @internal */
+export const PROMISES: WeakMap<Scope, Promise<any>[]>;
+
+/** @internal */
+export const ADD_PROMISE: (scope: Scope, promise: Promise<any>) => void;