@equipe-tech/observability 0.1.0 → 0.2.1

package/dist/testing/index.js

@@ -21,11 +21,14 @@ const ExportedSpan = Schema.Struct({
     spanId: Schema.String,
     parentSpanId: Schema.String.pipe(Schema.optionalKey),
     name: Schema.String,
+    kind: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
     status: Schema.Struct({
         code: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
         message: Schema.String.pipe(Schema.optionalKey),
     }).pipe(Schema.withDecodingDefault(Effect.succeed({ code: 0 }))),
     attributes: Attributes,
+    events: Schema.Array(Schema.Struct({ name: Schema.String })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+    links: Schema.Array(Schema.Struct({ spanId: Schema.String })).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
 });
 const SpanExport = Schema.Struct({
     resourceSpans: Schema.Array(Schema.Struct({
@@ -51,11 +54,35 @@ const MetricDataPoint = Schema.Struct({
     asDouble: Schema.Number.pipe(Schema.optionalKey),
     asInt: Schema.Union([Schema.String, Schema.Number]).pipe(Schema.optionalKey),
 });
-const DataPoints = Schema.Struct({ dataPoints: Schema.Array(MetricDataPoint) });
+const NumberDataPoints = Schema.Struct({ dataPoints: Schema.Array(MetricDataPoint) });
+const HistogramDataPoint = Schema.Struct({
+    attributes: Attributes,
+    count: Schema.Number,
+    sum: Schema.Number,
+    min: Schema.Number,
+    max: Schema.Number,
+    explicitBounds: Schema.Array(Schema.Number),
+    bucketCounts: Schema.Array(Schema.Number),
+});
 const ExportedMetric = Schema.Struct({
     name: Schema.String,
-    sum: DataPoints.pipe(Schema.optionalKey),
-    gauge: DataPoints.pipe(Schema.optionalKey),
+    description: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+    unit: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("1"))),
+    sum: Schema.Struct({
+        dataPoints: Schema.Array(MetricDataPoint),
+        isMonotonic: Schema.Boolean,
+        aggregationTemporality: Schema.Number,
+    }).pipe(Schema.optionalKey),
+    gauge: NumberDataPoints.pipe(Schema.optionalKey),
+    histogram: Schema.Struct({
+        dataPoints: Schema.Array(HistogramDataPoint),
+        aggregationTemporality: Schema.Number,
+    }).pipe(Schema.optionalKey),
+    exponentialHistogram: Schema.Struct({
+        dataPoints: Schema.Array(MetricDataPoint),
+        aggregationTemporality: Schema.Number,
+    }).pipe(Schema.optionalKey),
+    summary: NumberDataPoints.pipe(Schema.optionalKey),
 });
 const MetricExport = Schema.Struct({
     resourceMetrics: Schema.Array(Schema.Struct({
@@ -85,6 +112,10 @@ const toAttributes = (attributes) => {
     }
     return converted;
 };
+const toCapturedMetricPoints = (dataPoints) => dataPoints.map((dataPoint) => ({
+    value: Option.fromNullishOr(dataPoint.asDouble ?? dataPoint.asInt).pipe(Option.map(Number)),
+    attributes: toAttributes(dataPoint.attributes),
+}));
 export const attribute = (attributes, key) => Option.fromNullishOr(attributes.get(key));
 const captureClient = (store) => HttpClient.make((request, url) => Effect.gen(function* () {
     const body = request.body;
@@ -115,9 +146,12 @@ const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (
                             spanId: span.spanId,
                             parentSpanId: Option.fromNullishOr(span.parentSpanId),
                             name: span.name,
+                            kind: span.kind,
                             statusCode: span.status.code,
                             statusMessage: Option.fromNullishOr(span.status.message),
                             attributes: toAttributes(span.attributes),
+                            eventNames: span.events.map((event) => event.name),
+                            linkedSpanIds: span.links.map((link) => link.spanId),
                             resourceAttributes,
                         });
                     }
@@ -148,15 +182,63 @@ const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (
                 const resourceAttributes = toAttributes(resourceMetrics.resource.attributes);
                 for (const scopeMetrics of resourceMetrics.scopeMetrics) {
                     for (const metric of scopeMetrics.metrics) {
-                        const dataPoints = metric.sum?.dataPoints ?? metric.gauge?.dataPoints ?? [];
-                        metrics.push({
+                        const common = {
                             name: metric.name,
-                            points: dataPoints.map((dataPoint) => ({
-                                value: Option.fromNullishOr(dataPoint.asDouble ?? dataPoint.asInt).pipe(Option.map(Number)),
-                                attributes: toAttributes(dataPoint.attributes),
-                            })),
+                            description: metric.description,
+                            unit: metric.unit,
                             resourceAttributes,
-                        });
+                        };
+                        if (metric.sum !== undefined) {
+                            metrics.push({
+                                ...common,
+                                kind: "sum",
+                                points: toCapturedMetricPoints(metric.sum.dataPoints),
+                                isMonotonic: metric.sum.isMonotonic,
+                                aggregationTemporality: metric.sum.aggregationTemporality,
+                            });
+                        }
+                        else if (metric.gauge !== undefined) {
+                            metrics.push({
+                                ...common,
+                                kind: "gauge",
+                                points: toCapturedMetricPoints(metric.gauge.dataPoints),
+                            });
+                        }
+                        else if (metric.histogram !== undefined) {
+                            metrics.push({
+                                ...common,
+                                kind: "histogram",
+                                points: metric.histogram.dataPoints.map((dataPoint) => ({
+                                    value: Option.none(),
+                                    attributes: toAttributes(dataPoint.attributes),
+                                })),
+                                aggregationTemporality: metric.histogram.aggregationTemporality,
+                                histogramPoints: metric.histogram.dataPoints.map((dataPoint) => ({
+                                    attributes: toAttributes(dataPoint.attributes),
+                                    count: dataPoint.count,
+                                    sum: dataPoint.sum,
+                                    min: dataPoint.min,
+                                    max: dataPoint.max,
+                                    explicitBounds: dataPoint.explicitBounds,
+                                    bucketCounts: dataPoint.bucketCounts,
+                                })),
+                            });
+                        }
+                        else if (metric.exponentialHistogram !== undefined) {
+                            metrics.push({
+                                ...common,
+                                kind: "exponentialHistogram",
+                                points: toCapturedMetricPoints(metric.exponentialHistogram.dataPoints),
+                                aggregationTemporality: metric.exponentialHistogram.aggregationTemporality,
+                            });
+                        }
+                        else if (metric.summary !== undefined) {
+                            metrics.push({
+                                ...common,
+                                kind: "summary",
+                                points: toCapturedMetricPoints(metric.summary.dataPoints),
+                            });
+                        }
                     }
                 }
             }

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@equipe-tech/observability",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Contrato OpenTelemetry da Equipe Tech: configuracao, layer OTLP e wide events sobre Effect",
+  "homepage": "https://github.com/equipe-tech/observability#readme",
+  "bugs": {
+    "url": "https://github.com/equipe-tech/observability/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equipe-tech/observability.git",
+    "directory": "packages/telemetry"
+  },
   "files": [
     "dist"
   ],
@@ -12,6 +21,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./metrics": {
+      "types": "./dist/Metrics.d.ts",
+      "import": "./dist/Metrics.js"
+    },
     "./node": {
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.js"
@@ -24,6 +37,10 @@
       "types": "./dist/browser/index.d.ts",
       "import": "./dist/browser/index.js"
     },
+    "./browser/client": {
+      "types": "./dist/browser/client.d.ts",
+      "import": "./dist/browser/client.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
@@ -40,17 +57,22 @@
     "@nestjs/common": "^11.2.1",
     "@nestjs/core": "^11.2.1",
     "@nestjs/platform-express": "^11.2.1",
+    "evlog": "2.27.1",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
     "rxjs": "^7.2.0"
   },
   "peerDependenciesMeta": {
     "@nestjs/common": {
       "optional": true
     },
+    "@nestjs/core": {
+      "optional": true
+    },
     "rxjs": {
       "optional": true
     }