feat(proto): add @opentelemetry/proto package

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "experimental/packages/opentelemetry-exporter-metrics-otlp-proto/protos"]
 	path = experimental/packages/opentelemetry-exporter-metrics-otlp-proto/protos
 	url = https://github.com/open-telemetry/opentelemetry-proto.git
+[submodule "experimental/packages/opentelemetry-proto/opentelemetry-proto"]
+	path = experimental/packages/opentelemetry-proto/opentelemetry-proto
+	url = https://github.com/open-telemetry/opentelemetry-proto.git

experimental/packages/opentelemetry-proto/.eslintignore

@@ -0,0 +1,2 @@
+build
+src/opentelemetry

experimental/packages/opentelemetry-proto/.eslintrc.js

@@ -0,0 +1,8 @@
+module.exports = {
+    "env": {
+        "mocha": true,
+        "commonjs": true,
+        "shared-node-browser": true
+    },
+    ...require('../../../eslint.config.js')
+}

experimental/packages/opentelemetry-proto/.gitignore

@@ -0,0 +1 @@
+src/opentelemetry

experimental/packages/opentelemetry-proto/compile_proto.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+OUT_DIR="../src"
+TS_OUT_DIR="../src"
+IN_DIR="./opentelemetry"
+PROTOC="$(npm bin)/grpc_tools_node_protoc"
+PROTOC_GEN_TS_PATH="$(npm bin)/protoc-gen-ts"
+PROTOC_GEN_GRPC_PATH="$(npm bin)/grpc_tools_node_protoc_plugin"
+
+cd opentelemetry-proto
+
+$PROTOC \
+    -I="./" \
+    --plugin=protoc-gen-ts=$PROTOC_GEN_TS_PATH \
+    --js_out=import_style=commonjs:$OUT_DIR \
+    --ts_out=$TS_OUT_DIR \
+        opentelemetry/proto/collector/logs/v1/logs_service.proto \
+        opentelemetry/proto/collector/metrics/v1/metrics_service.proto \
+        opentelemetry/proto/collector/trace/v1/trace_service.proto

experimental/packages/opentelemetry-proto/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@opentelemetry/proto",
+  "private": true,
+  "version": "0.27.0",
+  "description": "OpenTelemetry Collector Metrics Exporter allows user to send collected metrics to the OpenTelemetry Collector",
+  "main": "build/src/index.js",
+  "types": "build/src/index.d.ts",
+  "repository": "open-telemetry/opentelemetry-js",
+  "scripts": {
+    "compile": "tsc --build",
+    "generate": "./compile_proto.sh",
+    "clean": "tsc --build --clean && rimraf src/opentelemetry",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "postcompile": "npm run submodule && npm run protos:copy",
+    "protos:copy": "cpx protos/opentelemetry/**/*.* build/protos/opentelemetry",
+    "submodule": "git submodule sync --recursive && git submodule update --init --recursive",
+    "tdd": "npm run test -- --watch-extensions ts --watch",
+    "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts'",
+    "watch": "npm run protos:copy && tsc -w",
+    "precompile": "npm run generate",
+    "prewatch": "npm run precompile"
+  },
+  "keywords": [
+    "opentelemetry",
+    "nodejs",
+    "grpc",
+    "tracing",
+    "profiling",
+    "metrics",
+    "stats"
+  ],
+  "author": "OpenTelemetry Authors",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "files": [
+    "build/src/**/*.js",
+    "build/src/**/*.js.map",
+    "build/src/**/*.d.ts",
+    "build/protos/**/*.proto",
+    "doc",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.0.3"
+  },
+  "devDependencies": {
+    "@babel/core": "7.16.0",
+    "@types/google-protobuf": "3.15.5",
+    "@types/mocha": "8.2.3",
+    "grpc-tools": "1.11.2",
+    "mocha": "7.2.0",
+    "protoc-gen-ts": "0.8.1",
+    "rimraf": "3.0.2",
+    "typescript": "4.4.4"
+  },
+  "dependencies": {
+    "@opentelemetry/api-metrics": "0.27.0",
+    "@opentelemetry/core": "1.0.1",
+    "@opentelemetry/resources": "1.0.1",
+    "@opentelemetry/sdk-metrics-base": "0.27.0",
+    "@opentelemetry/sdk-trace-base": "1.0.1",
+    "@grpc/grpc-js": "1.4.5",
+    "google-protobuf": "3.19.1"
+  }
+}

experimental/packages/opentelemetry-proto/src/common.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { SpanAttributes } from '@opentelemetry/api';
+import { opentelemetry as common } from './opentelemetry/proto/common/v1/common';
+
+const MAX_INTEGER_VALUE = 2147483647;
+const MIN_INTEGER_VALUE = -2147483648;
+
+export function toAttributes(
+    attributes: SpanAttributes
+): common.proto.common.v1.KeyValue[] {
+    return Object.keys(attributes).map(key => toKeyValue(key, attributes[key]));
+}
+
+export function toKeyValue(
+    key: string,
+    value: unknown
+): common.proto.common.v1.KeyValue {
+    return common.proto.common.v1.KeyValue.fromObject({
+        key: key,
+        value: toAnyValue(value),
+    })
+}
+
+export function toAnyValue(value: unknown): common.proto.common.v1.AnyValue {
+    return common.proto.common.v1.AnyValue.fromObject({
+        string_value: typeof value === 'string' ? value : undefined,
+        double_value: typeof value === 'number' && Number.isInteger(value) ? value : undefined,
+        int_value:
+            typeof value === 'number' &&
+                !Number.isInteger(value) &&
+                value > MIN_INTEGER_VALUE &&
+                value < MAX_INTEGER_VALUE
+                ? value
+                : undefined,
+        bool_value: typeof value === 'boolean' ? value : undefined,
+        bytes_value: value instanceof Buffer ? value : undefined,
+        array_value: Array.isArray(value) ? { values: value.map(v => toAnyValue(v)) } : undefined,
+    })
+}

experimental/packages/opentelemetry-proto/src/index.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './trace';

experimental/packages/opentelemetry-proto/src/metrics.ts

@@ -0,0 +1,135 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ValueType } from '@opentelemetry/api-metrics';
+import { hrTimeToNanoseconds } from '@opentelemetry/core';
+import { AggregatorKind, MetricKind, MetricRecord, Point, Histogram } from '@opentelemetry/sdk-metrics-base';
+import { toAttributes } from './common';
+import { opentelemetry as metrics_service } from './opentelemetry/proto/collector/metrics/v1/metrics_service';
+import { opentelemetry as metrics } from './opentelemetry/proto/metrics/v1/metrics';
+
+export function createExportMetricsServiceRequest(metricRecords: MetricRecord[], startTime: number): metrics_service.proto.collector.metrics.v1.ExportMetricsServiceRequest | null {
+    if (metricRecords.length === 0) {
+        return null;
+    }
+
+    const resource = metricRecords[0].resource;
+
+    return metrics_service.proto.collector.metrics.v1.ExportMetricsServiceRequest.fromObject({
+        resource_metrics: [{
+            resource: {
+                attributes: toAttributes(resource.attributes),
+                dropped_attributes_count: 0,
+            },
+            instrumentation_library_metrics: [{
+                instrumentation_library: { name: metricRecords[0].instrumentationLibrary.name, version: metricRecords[0].instrumentationLibrary.version },
+                schema_url: metricRecords[0].instrumentationLibrary.schemaUrl,
+                metrics: metricRecords.map(m => toMetric(m, startTime)),
+            }],
+        }],
+    });
+}
+
+function toMetric(metric: MetricRecord, startTime: number): metrics.proto.metrics.v1.Metric {
+    return metrics.proto.metrics.v1.Metric.fromObject({
+        description: metric.descriptor.description,
+        name: metric.descriptor.name,
+        unit: metric.descriptor.unit,
+        sum: isSum(metric) ? toSum(metric, startTime) : undefined,
+        gauge: metric.aggregator.kind === AggregatorKind.LAST_VALUE ? toGauge(metric, startTime) : undefined,
+        histogram: metric.aggregator.kind === AggregatorKind.HISTOGRAM ? toHistogram(metric, startTime) : undefined,
+    });
+}
+
+function isSum(metric: MetricRecord) {
+    return metric.aggregator.kind === AggregatorKind.SUM ||
+        metric.descriptor.metricKind === MetricKind.OBSERVABLE_COUNTER ||
+        metric.descriptor.metricKind === MetricKind.OBSERVABLE_UP_DOWN_COUNTER;
+}
+
+function toAggregationTemporality(
+    metric: MetricRecord
+): metrics.proto.metrics.v1.AggregationTemporality {
+    if (metric.descriptor.metricKind === MetricKind.OBSERVABLE_GAUGE) {
+        return metrics.proto.metrics.v1.AggregationTemporality.AGGREGATION_TEMPORALITY_UNSPECIFIED;
+    }
+
+    return metric.aggregationTemporality;
+}
+
+function toSum(
+    metric: MetricRecord,
+    startTime: number
+): metrics.proto.metrics.v1.Sum {
+    return metrics.proto.metrics.v1.Sum.fromObject({
+        data_points: [toNumberDataPoint(metric, startTime)],
+        is_monotonic:
+            metric.descriptor.metricKind === MetricKind.COUNTER ||
+            metric.descriptor.metricKind === MetricKind.OBSERVABLE_COUNTER,
+        aggregation_temporality: toAggregationTemporality(metric),
+    })
+}
+
+function toGauge(
+    metric: MetricRecord,
+    startTime: number
+): metrics.proto.metrics.v1.Gauge {
+    return metrics.proto.metrics.v1.Gauge.fromObject({
+        data_points: [toNumberDataPoint(metric, startTime)],
+    })
+}
+
+function toHistogram(
+    metric: MetricRecord,
+    startTime: number
+): metrics.proto.metrics.v1.Histogram {
+    return metrics.proto.metrics.v1.Histogram.fromObject({
+        data_points: [toHistogramDataPoint(metric, startTime)],
+        aggregation_temporality: toAggregationTemporality(metric),
+    });
+}
+
+function toNumberDataPoint(
+    metric: MetricRecord,
+    startTime: number
+): metrics.proto.metrics.v1.NumberDataPoint {
+    return metrics.proto.metrics.v1.NumberDataPoint.fromObject({
+        attributes: toAttributes(metric.attributes),
+        as_int: metric.descriptor.valueType === ValueType.INT ? metric.aggregator.toPoint().value as number : undefined,
+        as_double: metric.descriptor.valueType === ValueType.DOUBLE ? metric.aggregator.toPoint().value as number : undefined,
+        start_time_unix_nano: startTime,
+        time_unix_nano: hrTimeToNanoseconds(
+            metric.aggregator.toPoint().timestamp
+        ),
+    });
+}
+
+function toHistogramDataPoint(
+    metric: MetricRecord,
+    startTime: number
+): metrics.proto.metrics.v1.HistogramDataPoint {
+    const point = metric.aggregator.toPoint() as Point<Histogram>
+    return metrics.proto.metrics.v1.HistogramDataPoint.fromObject({
+        attributes: toAttributes(metric.attributes),
+        bucket_counts: point.value.buckets.counts,
+        explicit_bounds: point.value.buckets.boundaries,
+        count: point.value.count,
+        sum: point.value.sum,
+        start_time_unix_nano: startTime,
+        time_unix_nano: hrTimeToNanoseconds(
+            metric.aggregator.toPoint().timestamp
+        ),
+    })
+}