feat: add metrics and refactor tracing

Signed-off-by: Andrew Steurer <[email protected]>

Author: asteurer

README.md

@@ -9,6 +9,7 @@ Phase 0
 ### Champions
 
 - [Caleb Schoepp](https://github.com/calebschoepp)
+- [Andrew Steurer](https://github.com/asteurer)
 
 ### Portability Criteria
 

wit/deps/example-dep/example-api.wit

@@ -0,0 +1,90 @@
+package wasi:clocks@0.2.0;
+
+/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+/// time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A monotonic clock is a clock which has an unspecified initial value, and
+/// successive reads of the clock will produce non-decreasing values.
+///
+/// It is intended for measuring elapsed time.
+interface monotonic-clock {
+  use wasi:io/poll@0.2.0.{pollable};
+
+  /// An instant in time, in nanoseconds. An instant is relative to an
+  /// unspecified initial value, and can only be compared to instances from
+  /// the same monotonic-clock.
+  type instant = u64;
+
+  /// A duration of time, in nanoseconds.
+  type duration = u64;
+
+  /// Read the current value of the clock.
+  ///
+  /// The clock is monotonic, therefore calling this function repeatedly will
+  /// produce a sequence of non-decreasing values.
+  now: func() -> instant;
+
+  /// Query the resolution of the clock. Returns the duration of time
+  /// corresponding to a clock tick.
+  resolution: func() -> duration;
+
+  /// Create a `pollable` which will resolve once the specified instant
+  /// occured.
+  subscribe-instant: func(when: instant) -> pollable;
+
+  /// Create a `pollable` which will resolve once the given duration has
+  /// elapsed, starting at the time at which this function was called.
+  /// occured.
+  subscribe-duration: func(when: duration) -> pollable;
+}
+
+/// WASI Wall Clock is a clock API intended to let users query the current
+/// time. The name "wall" makes an analogy to a "clock on the wall", which
+/// is not necessarily monotonic as it may be reset.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A wall clock is a clock which measures the date and time according to
+/// some external reference.
+///
+/// External references may be reset, so this clock is not necessarily
+/// monotonic, making it unsuitable for measuring elapsed time.
+///
+/// It is intended for reporting the current date and time for humans.
+interface wall-clock {
+  /// A time and date in seconds plus nanoseconds.
+  record datetime {
+    seconds: u64,
+    nanoseconds: u32,
+  }
+
+  /// Read the current value of the clock.
+  ///
+  /// This clock is not monotonic, therefore calling this function repeatedly
+  /// will not necessarily produce a sequence of non-decreasing values.
+  ///
+  /// The returned timestamps represent the number of seconds since
+  /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+  /// also known as [Unix Time].
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  ///
+  /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+  /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+  now: func() -> datetime;
+
+  /// Query the resolution of the clock.
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  resolution: func() -> datetime;
+}
+
+world imports {
+  import wasi:io/poll@0.2.0;
+  import monotonic-clock;
+  import wall-clock;
+}

wit/deps/wasi-clocks-0.2.0/package.wit

@@ -0,0 +1,11 @@
+package wasi:io@0.2.0;
+
+interface poll {
+  resource pollable {
+    ready: func() -> bool;
+    block: func();
+  }
+
+  poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}
+

wit/deps/wasi-io-0.2.0/package.wit

@@ -0,0 +1,272 @@
+interface metrics {
+    use wasi:clocks/wall-clock@0.2.0.{datetime};
+    use wasi:clocks/monotonic-clock@0.2.0.{duration};
+    use types.{key-value, instrumentation-scope};
+    use tracing.{span-id, trace-id};
+
+    /// `collect` gathers all metric data related to a Reader from the SDK
+    collect: func(metrics: resource-metrics) -> result<_, otel-error>;
+
+    /// `resource-metrics` is a collection of `scope-metrics` and the associated `resource`
+    /// that created them.
+    ///
+    /// See https://github.com/open-telemetry/opentelemetry-rust/blob/c811cde1ae21c624870c1b952190e687b16f76b8/opentelemetry-sdk/src/metrics/data/mod.rs#L13
+    record resource-metrics {
+        /// The entity that collected the metrics.
+        %resource: %resource,
+        /// The collection of metrics with unique `instrumentation-scope`s.
+        scope-metrics: list<scope-metrics>,
+    }
+
+    /// An immutable representation of the entity producing telemetry as attributes.
+    record %resource {
+        inner: resource-inner,
+    }
+
+    /// Inner structure of `resource` holding the actual data.
+    record resource-inner {
+        attributes: list<key-value>,
+        schema-url: option<string>,
+    }
+
+    /// `scope-metrics` is a collection of `metric`s produced by a meter.
+    record scope-metrics {
+        /// The `instrumentation-scope` that the meter was created with.
+        scope: instrumentation-scope,
+        /// The list of aggregations created by the meter.
+        metrics: list<metric>,
+    }
+
+    /// `metric` is a collection of one or more aggregated time series from an instrument
+    record metric {
+        /// The name of the instrument that created this data.
+        name: string,
+        /// The description of the instrument, which can be used in documentation.
+        description: string,
+        /// The unit in which the instrument reports.
+        unit: string,
+        /// The aggregated data from an instrument.
+        data: aggregated-metrics,
+    }
+
+    /// Aggregated metrics data from an instrument.
+    variant aggregated-metrics {
+        /// All metric data with `f64` value type.
+        %f64(metric-data),
+        /// All metric data with `u64` value type.
+        %u64(metric-data),
+        /// All metric data with `s64` value type.
+        %s64(metric-data),
+    }
+
+    /// Metric data for all types.
+    variant metric-data {
+        /// Metric data for `gauge`.
+        gauge(gauge),
+        /// Metric data for `sum`.
+        sum(sum),
+        /// Metric data for `histogram`.
+        histogram(histogram),
+        /// Metric data for `exponential-histogram`.
+        exponential-histogram(exponential-histogram),
+    }
+
+    /// A measurement of the current value of an instrument.
+    record gauge {
+        /// Represents individual aggregated measurements with unique attributes.
+        data-points: list<gauge-data-point>,
+        /// The time when the time series was started.
+        start-time: option<datetime>,
+        /// The time when the time series was recorded.
+        time: datetime,
+    }
+
+    /// `gauge-data-point` is a single data point in a time series.
+    record gauge-data-point {
+        /// `attributes` is the set of key value pairs that uniquely identify the
+        /// time series.
+        attributes: list<key-value>,
+        /// The value of this data point.
+        value: metric-number,
+        /// The sampled `exemplar`s collected during the time series.
+        exemplars: list<exemplar>,
+    }
+
+    /// Represents the sum of all measurements of values from an instrument.
+    record sum {
+         /// Represents individual aggregated measurements with unique attributes.
+        data-points: list<sum-data-point>,
+        /// The time when the time series was started.
+        start-time: datetime,
+        /// The time when the time series was recorded.
+        time: datetime,
+        /// Describes if the aggregation is reported as the change from the last report
+        /// time, or the cumulative changes since a fixed start time.
+        temporality: temporality,
+        /// Whether this aggregation only increases or decreases.
+        is-monotonic: bool,
+    }
+
+    /// `sum-data-point` is a single data point in a time series.
+    record sum-data-point {
+        /// `attributes` is the set of key value pairs that uniquely identify the
+        /// time series.
+        attributes: list<key-value>,
+        /// The value of this data point.
+        value: metric-number,
+        /// The sampled `exemplar`s collected during the time series.
+        exemplars: list<exemplar>,
+    }
+
+    /// Represents the histogram of all measurements of values from an instrument.
+    record histogram {
+        /// Individual aggregated measurements with unique attributes.
+        data-points: list<histogram-data-point>,
+        /// The time when the time series was started.
+        start-time: datetime,
+        /// The time when the time series was recorded.
+        time: datetime,
+        /// Describes if the aggregation is reported as the change from the last report
+        /// time, or the cumulative changes since a fixed start time.
+        temporality: temporality,
+    }
+
+    /// A single histogram data point in a time series.
+    record histogram-data-point {
+        /// The set of key value pairs that uniquely identify the time series.
+        attributes: list<key-value>,
+        /// The number of updates this histogram has been calculated with.
+        count: u64,
+        /// The upper bounds of the buckets of the histogram.
+        bounds: list<f64>,
+        /// The count of each of the buckets.
+        bucket-counts: list<u64>,
+        /// The minimum value recorded.
+        min: option<metric-number>,
+        /// The maximum value recorded.
+        max: option<metric-number>,
+        /// The sum of the values recorded
+        sum: metric-number,
+        /// The sampled `exemplar`s collected during the time series.
+        exemplars: list<exemplar>,
+    }
+
+    /// The histogram of all measurements of values from an instrument.
+    record exponential-histogram {
+        /// The individual aggregated measurements with unique attributes.
+        data-points: list<exponential-histogram-data-point>,
+        /// When the time series was started.
+        start-time: datetime,
+        /// The time when the time series was recorded.
+        time: datetime,
+        /// Describes if the aggregation is reported as the change from the last report
+        /// time, or the cumulative changes since a fixed start time.
+        temporality: temporality,
+    }
+
+    /// A single exponential histogram data point in a time series.
+    record exponential-histogram-data-point {
+        /// The set of key value pairs that uniquely identify the time series.
+        attributes: list<key-value>,
+        /// The number of updates this histogram has been calculated with.
+        count: u64, // TODO: check that u64 is an acceptable replacement for usize
+        /// The minimum value recorded.
+        min: option<metric-number>,
+        /// The maximum value recorded.
+        max: option<metric-number>,
+        /// The maximum value recorded.
+        sum: metric-number,
+        /// Describes the resolution of the histogram.
+        ///
+        /// Boundaries are located at powers of the base, where:
+        ///
+        ///   base = 2 ^ (2 ^ -scale)
+        scale: s8,
+        /// The number of values whose absolute value is less than or equal to
+        /// `zero_threshold`.
+        ///
+        /// When `zero_threshold` is `0`, this is the number of values that cannot be
+        /// expressed using the standard exponential formula as well as values that have
+        /// been rounded to zero.
+        zero-count: u64,
+        /// The range of positive value bucket counts.
+        positive-bucket: exponential-bucket,
+        /// The range of negative value bucket counts.
+        negative-bucket: exponential-bucket,
+        /// The width of the zero region.
+        ///
+        /// Where the zero region is defined as the closed interval
+        /// [-zero_threshold, zero_threshold].
+        zero-threshold: f64,
+        /// The sampled exemplars collected during the time series.
+        exemplars: list<exemplar>,
+    }
+
+    /// A set of bucket counts, encoded in a contiguous array of counts.
+    record exponential-bucket {
+        /// The bucket index of the first entry in the `counts` list.
+        offset: s32,
+        /// A list where `counts[i]` carries the count of the bucket at index `offset + i`.
+        ///
+        /// `counts[i]` is the count of values greater than base^(offset+i) and less than
+        /// or equal to base^(offset+i+1).
+        counts: list<u64>,
+    }
+
+    /// A measurement sampled from a time series providing a typical example.
+    record exemplar {
+         /// The attributes recorded with the measurement but filtered out of the
+        /// time series' aggregated data.
+        filtered-attributes: list<key-value>,
+        /// The time when the measurement was recorded.
+        time: datetime,
+        /// The measured value.
+        value: metric-number,
+        /// The ID of the span that was active during the measurement.
+        ///
+        /// If no span was active or the span was not sampled this will be empty.
+        span-id: span-id,
+        /// The ID of the trace the active span belonged to during the measurement.
+        ///
+        /// If no span was active or the span was not sampled this will be empty.
+        trace-id: trace-id,
+    }
+
+    /// Defines the window that an aggregation was calculated over.
+    enum temporality {
+        /// A measurement interval that continues to expand forward in time from a
+        /// starting point.
+        ///
+        /// New measurements are added to all previous measurements since a start time.
+        ///
+        /// This is the default temporality
+        cumulative,
+        /// A measurement interval that resets each cycle.
+        ///
+        /// Measurements from one cycle are recorded independently, measurements from
+        /// other cycles do not affect them.
+        delta,
+        /// Configures Synchronous Counter and Histogram instruments to use
+        /// Delta aggregation temporality, which allows them to shed memory
+        /// following a cardinality explosion, thus use less memory.
+        low-memory,
+    }
+
+    /// The number types available for use with the OpenTelemetry SDKs.
+    ///
+    /// This makes it easier to use generics when converting to and from WASI data types.
+    variant metric-number {
+        %f64(f64),
+        %s64(s64),
+        %u64(u64),
+    }
+
+    /// The WASI representation of the `OTelSdkError`.
+    ///
+    /// See https://github.com/open-telemetry/opentelemetry-rust/blob/353bbb0d80fc35a26a00b4f4fed0dcaed23e5523/opentelemetry-sdk/src/error.rs#L15
+    variant otel-error {
+        already-shutdown,
+        timeout(duration),
+        internal-failure(string),
+    }
+}