From 99d88545e06f284037da15fa78934a784117543f Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Fri, 10 Jul 2020 14:38:53 +0200 Subject: [PATCH 01/10] feat: adding proto over http for collector exporter --- .nycrc | 1 + .../docker/collector-config.yaml | 8 +- .../docker/docker-compose.yaml | 6 - examples/collector-exporter-node/package.json | 3 +- examples/collector-exporter-node/start.js | 3 +- .../README.md | 27 +- .../opentelemetry-exporter-collector/gen.sh | 13 + .../collector/trace/v1/trace_service_pb.js | 323 +++ .../proto/common/v1/common_pb.js | 692 ++++++ .../proto/resource/v1/resource_pb.js | 229 ++ .../opentelemetry/proto/trace/v1/trace_pb.js | 2067 +++++++++++++++++ .../package.json | 9 +- .../src/enums.ts | 1 + .../platform/node/CollectorTraceExporter.ts | 37 +- .../src/platform/node/README.md | 7 + .../src/platform/node/transformSpansProto.ts | 313 +++ .../src/platform/node/util.ts | 59 + .../src/platform/node/utilWithJson.ts | 56 +- .../src/platform/node/utilWithJsonProto.ts | 61 + .../test/node/CollectorTraceExporter.test.ts | 2 +- .../test/node/transformSpansProto.test.ts | 383 +++ .../tsconfig.json | 1 + 22 files changed, 4237 insertions(+), 64 deletions(-) create mode 100755 packages/opentelemetry-exporter-collector/gen.sh create mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js create mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js create mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js create mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js create mode 100644 packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts create mode 100644 packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts create mode 100644 packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts diff --git a/.nycrc b/.nycrc index 47b8c170df..53a2f2262d 100644 --- a/.nycrc +++ b/.nycrc @@ -5,6 +5,7 @@ "exclude": [ "**/*.d.ts", "build/**/*.*", + "generated/**/*.*", "src/index.ts", "src/platform/**/index.ts", "src/platform/browser/*.ts", diff --git a/examples/collector-exporter-node/docker/collector-config.yaml b/examples/collector-exporter-node/docker/collector-config.yaml index 8ea773375b..7e0cd7e759 100644 --- a/examples/collector-exporter-node/docker/collector-config.yaml +++ b/examples/collector-exporter-node/docker/collector-config.yaml @@ -1,5 +1,11 @@ receivers: - otlp: {} + otlp: + {} +# keep it when upgrading to version 0.5+ +# protocols: +# grpc: +# http: +# endpoint: localhost:55680 exporters: zipkin: diff --git a/examples/collector-exporter-node/docker/docker-compose.yaml b/examples/collector-exporter-node/docker/docker-compose.yaml index 53c635a0f4..df43b97e33 100644 --- a/examples/collector-exporter-node/docker/docker-compose.yaml +++ b/examples/collector-exporter-node/docker/docker-compose.yaml @@ -3,8 +3,6 @@ services: # Collector collector: image: otel/opentelemetry-collector:0.4.0 - networks: - - otelcol command: ["--config=/conf/collector-config.yaml", "--log-level=DEBUG"] volumes: - ./collector-config.yaml:/conf/collector-config.yaml @@ -15,10 +13,6 @@ services: # Zipkin zipkin-all-in-one: image: openzipkin/zipkin:latest - networks: - - otelcol ports: - "9411:9411" -networks: - otelcol: diff --git a/examples/collector-exporter-node/package.json b/examples/collector-exporter-node/package.json index 5f5d7b39e6..ac987ef149 100644 --- a/examples/collector-exporter-node/package.json +++ b/examples/collector-exporter-node/package.json @@ -6,7 +6,8 @@ "main": "index.js", "scripts": { "start": "node ./start.js", - "docker:start": "cd ./docker && docker-compose down && docker-compose up -d", + "docker:start": "cd ./docker && docker-compose down && docker-compose up", + "docker:startd": "cd ./docker && docker-compose down && docker-compose up -d", "docker:stop": "cd ./docker && docker-compose down" }, "repository": { diff --git a/examples/collector-exporter-node/start.js b/examples/collector-exporter-node/start.js index 3f8f939653..dd24a94c7d 100644 --- a/examples/collector-exporter-node/start.js +++ b/examples/collector-exporter-node/start.js @@ -9,7 +9,8 @@ const exporter = new CollectorTraceExporter({ // headers: { // foo: 'bar' // }, - protocolNode: CollectorProtocolNode.HTTP_JSON, + protocolNode: CollectorProtocolNode.HTTP_JSON_PROTO, + // protocolNode: CollectorProtocolNode.HTTP_JSON, }); const provider = new BasicTracerProvider(); diff --git a/packages/opentelemetry-exporter-collector/README.md b/packages/opentelemetry-exporter-collector/README.md index 8cfda2f5a2..89431bdbaf 100644 --- a/packages/opentelemetry-exporter-collector/README.md +++ b/packages/opentelemetry-exporter-collector/README.md @@ -132,10 +132,33 @@ provider.register(); ``` +## Usage in Node - PROTO over http + +```js +const { BasicTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/tracing'); +const { CollectorExporter, CollectorTransportNode } = require('@opentelemetry/exporter-collector'); + +const collectorOptions = { + protocolNode: CollectorTransportNode.HTTP_PROTO, + serviceName: 'basic-service', + url: '', // url is optional and can be omitted - default is http://localhost:55680/v1/trace + headers: { + foo: 'bar' + }, //an optional object containing custom headers to be sent with each request will only work with json over http +}; + +const provider = new BasicTracerProvider(); +const exporter = new CollectorExporter(collectorOptions); +provider.addSpanProcessor(new SimpleSpanProcessor(exporter)); + +provider.register(); + +``` + ## Running opentelemetry-collector locally to see the traces -1. Go to examples/basic-tracer-node -2. run `npm run collector:docker:ot` +1. Go to examples/collector-exporter-node +2. run `npm run docker:start` 3. Open page at `http://localhost:9411/zipkin/` to observe the traces ## Useful links diff --git a/packages/opentelemetry-exporter-collector/gen.sh b/packages/opentelemetry-exporter-collector/gen.sh new file mode 100755 index 0000000000..7404879bb9 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/gen.sh @@ -0,0 +1,13 @@ +clear +git submodule sync --recursive +git submodule update --init --recursive + +OUT_DIR="./generated" + +protoc \ + --js_out="import_style=commonjs,binary:${OUT_DIR}" \ + --proto_path="src/platform/node/protos/" \ + opentelemetry/proto/common/v1/common.proto \ + opentelemetry/proto/resource/v1/resource.proto \ + opentelemetry/proto/trace/v1/trace.proto \ + opentelemetry/proto/collector/trace/v1/trace_service.proto \ diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js new file mode 100644 index 0000000000..606e2dd104 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js @@ -0,0 +1,323 @@ +// source: opentelemetry/proto/collector/trace/v1/trace_service.proto +// source: opentelemetry/proto/collector/trace/v1/trace_service.proto +/** + * @fileoverview + * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +var opentelemetry_proto_trace_v1_trace_pb = require('../../../../../opentelemetry/proto/trace/v1/trace_pb.js'); +goog.object.extend(proto, opentelemetry_proto_trace_v1_trace_pb); +goog.exportSymbol('proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest', null, global); +goog.exportSymbol('proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.displayName = 'proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.displayName = 'proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse'; +} + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.toObject = function(includeInstance, msg) { + var f, obj = { + resourceSpansList: jspb.Message.toObjectList(msg.getResourceSpansList(), + opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest; + return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new opentelemetry_proto_trace_v1_trace_pb.ResourceSpans; + reader.readMessage(value,opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.deserializeBinaryFromReader); + msg.addResourceSpans(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getResourceSpansList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated opentelemetry.proto.trace.v1.ResourceSpans resource_spans = 1; + * @return {!Array} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.getResourceSpansList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_trace_v1_trace_pb.ResourceSpans, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} returns this +*/ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.setResourceSpansList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.addResourceSpans = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.opentelemetry.proto.trace.v1.ResourceSpans, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} returns this + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.clearResourceSpansList = function() { + return this.setResourceSpansList([]); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse; + return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + +goog.object.extend(exports, proto.opentelemetry.proto.collector.trace.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js new file mode 100644 index 0000000000..796ad90f6a --- /dev/null +++ b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js @@ -0,0 +1,692 @@ +// source: opentelemetry/proto/common/v1/common.proto +/** + * @fileoverview + * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.opentelemetry.proto.common.v1.AttributeKeyValue', null, global); +goog.exportSymbol('proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType', null, global); +goog.exportSymbol('proto.opentelemetry.proto.common.v1.InstrumentationLibrary', null, global); +goog.exportSymbol('proto.opentelemetry.proto.common.v1.StringKeyValue', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.opentelemetry.proto.common.v1.AttributeKeyValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.common.v1.AttributeKeyValue.displayName = 'proto.opentelemetry.proto.common.v1.AttributeKeyValue'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.common.v1.StringKeyValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.opentelemetry.proto.common.v1.StringKeyValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.common.v1.StringKeyValue.displayName = 'proto.opentelemetry.proto.common.v1.StringKeyValue'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.opentelemetry.proto.common.v1.InstrumentationLibrary, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.common.v1.InstrumentationLibrary.displayName = 'proto.opentelemetry.proto.common.v1.InstrumentationLibrary'; +} + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.common.v1.AttributeKeyValue.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.toObject = function(includeInstance, msg) { + var f, obj = { + key: jspb.Message.getFieldWithDefault(msg, 1, ""), + type: jspb.Message.getFieldWithDefault(msg, 2, 0), + stringValue: jspb.Message.getFieldWithDefault(msg, 3, ""), + intValue: jspb.Message.getFieldWithDefault(msg, 4, 0), + doubleValue: jspb.Message.getFloatingPointFieldWithDefault(msg, 5, 0.0), + boolValue: jspb.Message.getBooleanFieldWithDefault(msg, 6, false) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.common.v1.AttributeKeyValue; + return proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 2: + var value = /** @type {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} */ (reader.readEnum()); + msg.setType(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setStringValue(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt64()); + msg.setIntValue(value); + break; + case 5: + var value = /** @type {number} */ (reader.readDouble()); + msg.setDoubleValue(value); + break; + case 6: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setBoolValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.common.v1.AttributeKeyValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getType(); + if (f !== 0.0) { + writer.writeEnum( + 2, + f + ); + } + f = message.getStringValue(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getIntValue(); + if (f !== 0) { + writer.writeInt64( + 4, + f + ); + } + f = message.getDoubleValue(); + if (f !== 0.0) { + writer.writeDouble( + 5, + f + ); + } + f = message.getBoolValue(); + if (f) { + writer.writeBool( + 6, + f + ); + } +}; + + +/** + * @enum {number} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType = { + STRING: 0, + INT: 1, + DOUBLE: 2, + BOOL: 3 +}; + +/** + * optional string key = 1; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional ValueType type = 2; + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getType = function() { + return /** @type {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setType = function(value) { + return jspb.Message.setProto3EnumField(this, 2, value); +}; + + +/** + * optional string string_value = 3; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getStringValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setStringValue = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional int64 int_value = 4; + * @return {number} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getIntValue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setIntValue = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional double double_value = 5; + * @return {number} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getDoubleValue = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 5, 0.0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setDoubleValue = function(value) { + return jspb.Message.setProto3FloatField(this, 5, value); +}; + + +/** + * optional bool bool_value = 6; + * @return {boolean} + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getBoolValue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 6, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setBoolValue = function(value) { + return jspb.Message.setProto3BooleanField(this, 6, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.common.v1.StringKeyValue.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.toObject = function(includeInstance, msg) { + var f, obj = { + key: jspb.Message.getFieldWithDefault(msg, 1, ""), + value: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.common.v1.StringKeyValue; + return proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.common.v1.StringKeyValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getValue(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string key = 1; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string value = 2; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.getValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} returns this + */ +proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.setValue = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.common.v1.InstrumentationLibrary.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + version: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.common.v1.InstrumentationLibrary; + return proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setVersion(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.common.v1.InstrumentationLibrary.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getVersion(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} returns this + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string version = 2; + * @return {string} + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.getVersion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} returns this + */ +proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.setVersion = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +goog.object.extend(exports, proto.opentelemetry.proto.common.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js new file mode 100644 index 0000000000..d03e6a365e --- /dev/null +++ b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js @@ -0,0 +1,229 @@ +// source: opentelemetry/proto/resource/v1/resource.proto +/** + * @fileoverview + * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +var opentelemetry_proto_common_v1_common_pb = require('../../../../opentelemetry/proto/common/v1/common_pb.js'); +goog.object.extend(proto, opentelemetry_proto_common_v1_common_pb); +goog.exportSymbol('proto.opentelemetry.proto.resource.v1.Resource', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.resource.v1.Resource = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.resource.v1.Resource.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.resource.v1.Resource, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.resource.v1.Resource.displayName = 'proto.opentelemetry.proto.resource.v1.Resource'; +} + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.resource.v1.Resource.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.resource.v1.Resource.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.resource.v1.Resource} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.resource.v1.Resource.toObject = function(includeInstance, msg) { + var f, obj = { + attributesList: jspb.Message.toObjectList(msg.getAttributesList(), + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), + droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.resource.v1.Resource} + */ +proto.opentelemetry.proto.resource.v1.Resource.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.resource.v1.Resource; + return proto.opentelemetry.proto.resource.v1.Resource.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.resource.v1.Resource} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.resource.v1.Resource} + */ +proto.opentelemetry.proto.resource.v1.Resource.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; + reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); + msg.addAttributes(value); + break; + case 2: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedAttributesCount(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.resource.v1.Resource.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.resource.v1.Resource} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.resource.v1.Resource.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAttributesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter + ); + } + f = message.getDroppedAttributesCount(); + if (f !== 0) { + writer.writeUint32( + 2, + f + ); + } +}; + + +/** + * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 1; + * @return {!Array} + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.getAttributesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this +*/ +proto.opentelemetry.proto.resource.v1.Resource.prototype.setAttributesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.addAttributes = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.clearAttributesList = function() { + return this.setAttributesList([]); +}; + + +/** + * optional uint32 dropped_attributes_count = 2; + * @return {number} + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.getDroppedAttributesCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this + */ +proto.opentelemetry.proto.resource.v1.Resource.prototype.setDroppedAttributesCount = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +goog.object.extend(exports, proto.opentelemetry.proto.resource.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js new file mode 100644 index 0000000000..42a4524c1f --- /dev/null +++ b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js @@ -0,0 +1,2067 @@ +// source: opentelemetry/proto/trace/v1/trace.proto +/** + * @fileoverview + * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +var opentelemetry_proto_common_v1_common_pb = require('../../../../opentelemetry/proto/common/v1/common_pb.js'); +goog.object.extend(proto, opentelemetry_proto_common_v1_common_pb); +var opentelemetry_proto_resource_v1_resource_pb = require('../../../../opentelemetry/proto/resource/v1/resource_pb.js'); +goog.object.extend(proto, opentelemetry_proto_resource_v1_resource_pb); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.ResourceSpans', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.Event', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.Link', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.SpanKind', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Status', null, global); +goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Status.StatusCode', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.ResourceSpans.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.ResourceSpans, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.ResourceSpans.displayName = 'proto.opentelemetry.proto.trace.v1.ResourceSpans'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.displayName = 'proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.Span = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.Span, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.Span.displayName = 'proto.opentelemetry.proto.trace.v1.Span'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.Span.Event = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.Event.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.Span.Event, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.Span.Event.displayName = 'proto.opentelemetry.proto.trace.v1.Span.Event'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.Span.Link = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.Link.repeatedFields_, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.Span.Link, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.Span.Link.displayName = 'proto.opentelemetry.proto.trace.v1.Span.Link'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.opentelemetry.proto.trace.v1.Status = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.opentelemetry.proto.trace.v1.Status, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.opentelemetry.proto.trace.v1.Status.displayName = 'proto.opentelemetry.proto.trace.v1.Status'; +} + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.ResourceSpans.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.toObject = function(includeInstance, msg) { + var f, obj = { + resource: (f = msg.getResource()) && opentelemetry_proto_resource_v1_resource_pb.Resource.toObject(includeInstance, f), + instrumentationLibrarySpansList: jspb.Message.toObjectList(msg.getInstrumentationLibrarySpansList(), + proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.ResourceSpans; + return proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new opentelemetry_proto_resource_v1_resource_pb.Resource; + reader.readMessage(value,opentelemetry_proto_resource_v1_resource_pb.Resource.deserializeBinaryFromReader); + msg.setResource(value); + break; + case 2: + var value = new proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans; + reader.readMessage(value,proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader); + msg.addInstrumentationLibrarySpans(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.ResourceSpans.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getResource(); + if (f != null) { + writer.writeMessage( + 1, + f, + opentelemetry_proto_resource_v1_resource_pb.Resource.serializeBinaryToWriter + ); + } + f = message.getInstrumentationLibrarySpansList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter + ); + } +}; + + +/** + * optional opentelemetry.proto.resource.v1.Resource resource = 1; + * @return {?proto.opentelemetry.proto.resource.v1.Resource} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.getResource = function() { + return /** @type{?proto.opentelemetry.proto.resource.v1.Resource} */ ( + jspb.Message.getWrapperField(this, opentelemetry_proto_resource_v1_resource_pb.Resource, 1)); +}; + + +/** + * @param {?proto.opentelemetry.proto.resource.v1.Resource|undefined} value + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this +*/ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.setResource = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.clearResource = function() { + return this.setResource(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.hasResource = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated InstrumentationLibrarySpans instrumentation_library_spans = 2; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.getInstrumentationLibrarySpansList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this +*/ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.setInstrumentationLibrarySpansList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.addInstrumentationLibrarySpans = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this + */ +proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.clearInstrumentationLibrarySpansList = function() { + return this.setInstrumentationLibrarySpansList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject = function(includeInstance, msg) { + var f, obj = { + instrumentationLibrary: (f = msg.getInstrumentationLibrary()) && opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.toObject(includeInstance, f), + spansList: jspb.Message.toObjectList(msg.getSpansList(), + proto.opentelemetry.proto.trace.v1.Span.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans; + return proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary; + reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.deserializeBinaryFromReader); + msg.setInstrumentationLibrary(value); + break; + case 2: + var value = new proto.opentelemetry.proto.trace.v1.Span; + reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader); + msg.addSpans(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getInstrumentationLibrary(); + if (f != null) { + writer.writeMessage( + 1, + f, + opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.serializeBinaryToWriter + ); + } + f = message.getSpansList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter + ); + } +}; + + +/** + * optional opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1; + * @return {?proto.opentelemetry.proto.common.v1.InstrumentationLibrary} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.getInstrumentationLibrary = function() { + return /** @type{?proto.opentelemetry.proto.common.v1.InstrumentationLibrary} */ ( + jspb.Message.getWrapperField(this, opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary, 1)); +}; + + +/** + * @param {?proto.opentelemetry.proto.common.v1.InstrumentationLibrary|undefined} value + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this +*/ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.setInstrumentationLibrary = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.clearInstrumentationLibrary = function() { + return this.setInstrumentationLibrary(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.hasInstrumentationLibrary = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated Span spans = 2; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.getSpansList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this +*/ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.setSpansList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.Span=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.trace.v1.Span} + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.addSpans = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.opentelemetry.proto.trace.v1.Span, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this + */ +proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.clearSpansList = function() { + return this.setSpansList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.trace.v1.Span.repeatedFields_ = [9,11,13]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.Span.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.Span} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.toObject = function(includeInstance, msg) { + var f, obj = { + traceId: msg.getTraceId_asB64(), + spanId: msg.getSpanId_asB64(), + traceState: jspb.Message.getFieldWithDefault(msg, 3, ""), + parentSpanId: msg.getParentSpanId_asB64(), + name: jspb.Message.getFieldWithDefault(msg, 5, ""), + kind: jspb.Message.getFieldWithDefault(msg, 6, 0), + startTimeUnixNano: jspb.Message.getFieldWithDefault(msg, 7, 0), + endTimeUnixNano: jspb.Message.getFieldWithDefault(msg, 8, 0), + attributesList: jspb.Message.toObjectList(msg.getAttributesList(), + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), + droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 10, 0), + eventsList: jspb.Message.toObjectList(msg.getEventsList(), + proto.opentelemetry.proto.trace.v1.Span.Event.toObject, includeInstance), + droppedEventsCount: jspb.Message.getFieldWithDefault(msg, 12, 0), + linksList: jspb.Message.toObjectList(msg.getLinksList(), + proto.opentelemetry.proto.trace.v1.Span.Link.toObject, includeInstance), + droppedLinksCount: jspb.Message.getFieldWithDefault(msg, 14, 0), + status: (f = msg.getStatus()) && proto.opentelemetry.proto.trace.v1.Status.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.Span} + */ +proto.opentelemetry.proto.trace.v1.Span.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.Span; + return proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.Span} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.Span} + */ +proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTraceId(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setSpanId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setTraceState(value); + break; + case 4: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setParentSpanId(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 6: + var value = /** @type {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} */ (reader.readEnum()); + msg.setKind(value); + break; + case 7: + var value = /** @type {number} */ (reader.readFixed64()); + msg.setStartTimeUnixNano(value); + break; + case 8: + var value = /** @type {number} */ (reader.readFixed64()); + msg.setEndTimeUnixNano(value); + break; + case 9: + var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; + reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); + msg.addAttributes(value); + break; + case 10: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedAttributesCount(value); + break; + case 11: + var value = new proto.opentelemetry.proto.trace.v1.Span.Event; + reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader); + msg.addEvents(value); + break; + case 12: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedEventsCount(value); + break; + case 13: + var value = new proto.opentelemetry.proto.trace.v1.Span.Link; + reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader); + msg.addLinks(value); + break; + case 14: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedLinksCount(value); + break; + case 15: + var value = new proto.opentelemetry.proto.trace.v1.Status; + reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader); + msg.setStatus(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.Span} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTraceId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getSpanId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getTraceState(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getParentSpanId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 4, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } + f = message.getKind(); + if (f !== 0.0) { + writer.writeEnum( + 6, + f + ); + } + f = message.getStartTimeUnixNano(); + if (f !== 0) { + writer.writeFixed64( + 7, + f + ); + } + f = message.getEndTimeUnixNano(); + if (f !== 0) { + writer.writeFixed64( + 8, + f + ); + } + f = message.getAttributesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 9, + f, + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter + ); + } + f = message.getDroppedAttributesCount(); + if (f !== 0) { + writer.writeUint32( + 10, + f + ); + } + f = message.getEventsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 11, + f, + proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter + ); + } + f = message.getDroppedEventsCount(); + if (f !== 0) { + writer.writeUint32( + 12, + f + ); + } + f = message.getLinksList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 13, + f, + proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter + ); + } + f = message.getDroppedLinksCount(); + if (f !== 0) { + writer.writeUint32( + 14, + f + ); + } + f = message.getStatus(); + if (f != null) { + writer.writeMessage( + 15, + f, + proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter + ); + } +}; + + +/** + * @enum {number} + */ +proto.opentelemetry.proto.trace.v1.Span.SpanKind = { + SPAN_KIND_UNSPECIFIED: 0, + INTERNAL: 1, + SERVER: 2, + CLIENT: 3, + PRODUCER: 4, + CONSUMER: 5 +}; + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.trace.v1.Span.Event.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.Span.Event.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.Event.toObject = function(includeInstance, msg) { + var f, obj = { + timeUnixNano: jspb.Message.getFieldWithDefault(msg, 1, 0), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + attributesList: jspb.Message.toObjectList(msg.getAttributesList(), + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), + droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 4, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.Span.Event; + return proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readFixed64()); + msg.setTimeUnixNano(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 3: + var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; + reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); + msg.addAttributes(value); + break; + case 4: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedAttributesCount(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTimeUnixNano(); + if (f !== 0) { + writer.writeFixed64( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getAttributesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter + ); + } + f = message.getDroppedAttributesCount(); + if (f !== 0) { + writer.writeUint32( + 4, + f + ); + } +}; + + +/** + * optional fixed64 time_unix_nano = 1; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getTimeUnixNano = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setTimeUnixNano = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 3; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getAttributesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setAttributesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.addAttributes = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.clearAttributesList = function() { + return this.setAttributesList([]); +}; + + +/** + * optional uint32 dropped_attributes_count = 4; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getDroppedAttributesCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setDroppedAttributesCount = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.opentelemetry.proto.trace.v1.Span.Link.repeatedFields_ = [4]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.Span.Link.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.Link.toObject = function(includeInstance, msg) { + var f, obj = { + traceId: msg.getTraceId_asB64(), + spanId: msg.getSpanId_asB64(), + traceState: jspb.Message.getFieldWithDefault(msg, 3, ""), + attributesList: jspb.Message.toObjectList(msg.getAttributesList(), + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), + droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 5, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.Span.Link; + return proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTraceId(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setSpanId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setTraceState(value); + break; + case 4: + var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; + reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); + msg.addAttributes(value); + break; + case 5: + var value = /** @type {number} */ (reader.readUint32()); + msg.setDroppedAttributesCount(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTraceId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getSpanId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getTraceState(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getAttributesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 4, + f, + opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter + ); + } + f = message.getDroppedAttributesCount(); + if (f !== 0) { + writer.writeUint32( + 5, + f + ); + } +}; + + +/** + * optional bytes trace_id = 1; + * @return {!(string|Uint8Array)} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes trace_id = 1; + * This is a type-conversion wrapper around `getTraceId()` + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTraceId())); +}; + + +/** + * optional bytes trace_id = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTraceId()` + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTraceId())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setTraceId = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional bytes span_id = 2; + * @return {!(string|Uint8Array)} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes span_id = 2; + * This is a type-conversion wrapper around `getSpanId()` + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getSpanId())); +}; + + +/** + * optional bytes span_id = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getSpanId()` + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getSpanId())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setSpanId = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string trace_state = 3; + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceState = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setTraceState = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 4; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getAttributesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 4)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setAttributesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 4, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.addAttributes = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 4, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.clearAttributesList = function() { + return this.setAttributesList([]); +}; + + +/** + * optional uint32 dropped_attributes_count = 5; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getDroppedAttributesCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setDroppedAttributesCount = function(value) { + return jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional bytes trace_id = 1; + * @return {!(string|Uint8Array)} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes trace_id = 1; + * This is a type-conversion wrapper around `getTraceId()` + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTraceId())); +}; + + +/** + * optional bytes trace_id = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTraceId()` + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTraceId())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setTraceId = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional bytes span_id = 2; + * @return {!(string|Uint8Array)} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes span_id = 2; + * This is a type-conversion wrapper around `getSpanId()` + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getSpanId())); +}; + + +/** + * optional bytes span_id = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getSpanId()` + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getSpanId())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setSpanId = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string trace_state = 3; + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceState = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setTraceState = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional bytes parent_span_id = 4; + * @return {!(string|Uint8Array)} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * optional bytes parent_span_id = 4; + * This is a type-conversion wrapper around `getParentSpanId()` + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getParentSpanId())); +}; + + +/** + * optional bytes parent_span_id = 4; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getParentSpanId()` + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getParentSpanId())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setParentSpanId = function(value) { + return jspb.Message.setProto3BytesField(this, 4, value); +}; + + +/** + * optional string name = 5; + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); +}; + + +/** + * optional SpanKind kind = 6; + * @return {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getKind = function() { + return /** @type {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setKind = function(value) { + return jspb.Message.setProto3EnumField(this, 6, value); +}; + + +/** + * optional fixed64 start_time_unix_nano = 7; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getStartTimeUnixNano = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setStartTimeUnixNano = function(value) { + return jspb.Message.setProto3IntField(this, 7, value); +}; + + +/** + * optional fixed64 end_time_unix_nano = 8; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getEndTimeUnixNano = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setEndTimeUnixNano = function(value) { + return jspb.Message.setProto3IntField(this, 8, value); +}; + + +/** + * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 9; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getAttributesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 9)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.prototype.setAttributesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 9, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.addAttributes = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 9, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.clearAttributesList = function() { + return this.setAttributesList([]); +}; + + +/** + * optional uint32 dropped_attributes_count = 10; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedAttributesCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 10, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedAttributesCount = function(value) { + return jspb.Message.setProto3IntField(this, 10, value); +}; + + +/** + * repeated Event events = 11; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getEventsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span.Event, 11)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.prototype.setEventsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 11, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.Span.Event=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.addEvents = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 11, opt_value, proto.opentelemetry.proto.trace.v1.Span.Event, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.clearEventsList = function() { + return this.setEventsList([]); +}; + + +/** + * optional uint32 dropped_events_count = 12; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedEventsCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 12, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedEventsCount = function(value) { + return jspb.Message.setProto3IntField(this, 12, value); +}; + + +/** + * repeated Link links = 13; + * @return {!Array} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getLinksList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span.Link, 13)); +}; + + +/** + * @param {!Array} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.prototype.setLinksList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 13, value); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.Span.Link=} opt_value + * @param {number=} opt_index + * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.addLinks = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 13, opt_value, proto.opentelemetry.proto.trace.v1.Span.Link, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.clearLinksList = function() { + return this.setLinksList([]); +}; + + +/** + * optional uint32 dropped_links_count = 14; + * @return {number} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedLinksCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 14, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedLinksCount = function(value) { + return jspb.Message.setProto3IntField(this, 14, value); +}; + + +/** + * optional Status status = 15; + * @return {?proto.opentelemetry.proto.trace.v1.Status} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.getStatus = function() { + return /** @type{?proto.opentelemetry.proto.trace.v1.Status} */ ( + jspb.Message.getWrapperField(this, proto.opentelemetry.proto.trace.v1.Status, 15)); +}; + + +/** + * @param {?proto.opentelemetry.proto.trace.v1.Status|undefined} value + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this +*/ +proto.opentelemetry.proto.trace.v1.Span.prototype.setStatus = function(value) { + return jspb.Message.setWrapperField(this, 15, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.clearStatus = function() { + return this.setStatus(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.opentelemetry.proto.trace.v1.Span.prototype.hasStatus = function() { + return jspb.Message.getField(this, 15) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.toObject = function(opt_includeInstance) { + return proto.opentelemetry.proto.trace.v1.Status.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.opentelemetry.proto.trace.v1.Status} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Status.toObject = function(includeInstance, msg) { + var f, obj = { + code: jspb.Message.getFieldWithDefault(msg, 1, 0), + message: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.opentelemetry.proto.trace.v1.Status} + */ +proto.opentelemetry.proto.trace.v1.Status.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.opentelemetry.proto.trace.v1.Status; + return proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.opentelemetry.proto.trace.v1.Status} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.opentelemetry.proto.trace.v1.Status} + */ +proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} */ (reader.readEnum()); + msg.setCode(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setMessage(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.opentelemetry.proto.trace.v1.Status} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCode(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getMessage(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * @enum {number} + */ +proto.opentelemetry.proto.trace.v1.Status.StatusCode = { + OK: 0, + CANCELLED: 1, + UNKNOWNERROR: 2, + INVALIDARGUMENT: 3, + DEADLINEEXCEEDED: 4, + NOTFOUND: 5, + ALREADYEXISTS: 6, + PERMISSIONDENIED: 7, + RESOURCEEXHAUSTED: 8, + FAILEDPRECONDITION: 9, + ABORTED: 10, + OUTOFRANGE: 11, + UNIMPLEMENTED: 12, + INTERNALERROR: 13, + UNAVAILABLE: 14, + DATALOSS: 15, + UNAUTHENTICATED: 16 +}; + +/** + * optional StatusCode code = 1; + * @return {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.getCode = function() { + return /** @type {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} value + * @return {!proto.opentelemetry.proto.trace.v1.Status} returns this + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.setCode = function(value) { + return jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * optional string message = 2; + * @return {string} + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.getMessage = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.opentelemetry.proto.trace.v1.Status} returns this + */ +proto.opentelemetry.proto.trace.v1.Status.prototype.setMessage = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +goog.object.extend(exports, proto.opentelemetry.proto.trace.v1); diff --git a/packages/opentelemetry-exporter-collector/package.json b/packages/opentelemetry-exporter-collector/package.json index d25876c93b..9edc6d7fbc 100644 --- a/packages/opentelemetry-exporter-collector/package.json +++ b/packages/opentelemetry-exporter-collector/package.json @@ -16,16 +16,18 @@ "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../", "precompile": "tsc --version", "compile": "npm run version:update && tsc -p .", - "postcompile": "npm run submodule && npm run protos:copy", + "generate:http-proto": "rimraf ./generated/* && ./gen.sh", + "postcompile": "npm run submodule && npm run protos:copy && npm run generated:copy", "prepare": "npm run compile", "protos:copy": "cpx src/platform/node/protos/opentelemetry/**/*.* build/src/platform/node/protos/opentelemetry", + "generated:copy": "cpx generated/**/*.* build/generated", "submodule": "git submodule sync --recursive && git submodule update --init --recursive", "tdd": "npm run test -- --watch-extensions ts --watch", "tdd:browser": "karma start", "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts' --exclude 'test/browser/**/*.ts'", "test:browser": "nyc karma start --single-run", "version:update": "node ../../scripts/version-update.js", - "watch": "npm run protos:copy && tsc -w" + "watch": "npm run protos:copy && npm run generated:copy && tsc -w" }, "keywords": [ "opentelemetry", @@ -55,6 +57,7 @@ }, "devDependencies": { "@babel/core": "7.10.3", + "@types/google-protobuf": "^3.7.2", "@types/mocha": "7.0.2", "@types/node": "14.0.14", "@types/sinon": "9.0.4", @@ -83,7 +86,7 @@ "webpack-merge": "4.2.2" }, "dependencies": { - "@grpc/proto-loader": "^0.5.3", + "@grpc/proto-loader": "^0.5.4", "@opentelemetry/api": "^0.9.0", "@opentelemetry/core": "^0.9.0", "@opentelemetry/resources": "^0.9.0", diff --git a/packages/opentelemetry-exporter-collector/src/enums.ts b/packages/opentelemetry-exporter-collector/src/enums.ts index 08c2fd9f2b..8e8e27a299 100644 --- a/packages/opentelemetry-exporter-collector/src/enums.ts +++ b/packages/opentelemetry-exporter-collector/src/enums.ts @@ -21,4 +21,5 @@ export enum CollectorProtocolNode { GRPC, HTTP_JSON, + HTTP_PROTO, } diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts index 4cdaf9e41d..936ffc7dd1 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts @@ -37,6 +37,11 @@ import { onInitWithJson, sendSpansUsingJson, } from './utilWithJson'; +import { + DEFAULT_COLLECTOR_URL_JSON_PROTO, + onInitWithJsonProto, + sendSpansUsingJsonProto, +} from './utilWithJsonProto'; /** * Collector Trace Exporter for Node @@ -63,16 +68,20 @@ export class CollectorTraceExporter extends CollectorTraceExporterBase< typeof config.protocolNode !== 'undefined' ? config.protocolNode : CollectorProtocolNode.GRPC; - if (this._protocol === CollectorProtocolNode.HTTP_JSON) { - this.logger.debug('CollectorExporter - using json over http'); - if (config.metadata) { - this.logger.warn('Metadata cannot be set when using json'); - } - } else { + if (this._protocol === CollectorProtocolNode.GRPC) { this.logger.debug('CollectorExporter - using grpc'); if (config.headers) { this.logger.warn('Headers cannot be set when using grpc'); } + } else { + if (this._protocol === CollectorProtocolNode.HTTP_JSON) { + this.logger.debug('CollectorExporter - using json over http'); + } else { + this.logger.debug('CollectorExporter - using proto over http'); + } + if (config.metadata) { + this.logger.warn('Metadata cannot be set when using http'); + } } this.metadata = config.metadata; this.headers = @@ -91,6 +100,8 @@ export class CollectorTraceExporter extends CollectorTraceExporterBase< if (config.protocolNode === CollectorProtocolNode.HTTP_JSON) { onInitWithJson(this, config); + } else if (config.protocolNode === CollectorProtocolNode.HTTP_PROTO) { + onInitWithJsonProto(this, config); } else { onInitWithGrpc(this, config); } @@ -107,6 +118,8 @@ export class CollectorTraceExporter extends CollectorTraceExporterBase< } if (this._protocol === CollectorProtocolNode.HTTP_JSON) { sendSpansUsingJson(this, spans, onSuccess, onError); + } else if (this._protocol === CollectorProtocolNode.HTTP_PROTO) { + sendSpansUsingJsonProto(this, spans, onSuccess, onError); } else { sendSpansUsingGrpc(this, spans, onSuccess, onError); } @@ -114,9 +127,15 @@ export class CollectorTraceExporter extends CollectorTraceExporterBase< getDefaultUrl(config: CollectorExporterConfigNode): string { if (!config.url) { - return config.protocolNode === CollectorProtocolNode.HTTP_JSON - ? DEFAULT_COLLECTOR_URL_JSON - : DEFAULT_COLLECTOR_URL_GRPC; + if (config.protocolNode === CollectorProtocolNode.HTTP_JSON) { + return DEFAULT_COLLECTOR_URL_JSON; + } else if ( + config.protocolNode === CollectorProtocolNode.HTTP_PROTO + ) { + return DEFAULT_COLLECTOR_URL_JSON_PROTO; + } else { + return DEFAULT_COLLECTOR_URL_GRPC; + } } return config.url; } diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/README.md b/packages/opentelemetry-exporter-collector/src/platform/node/README.md index 76ff2c2c49..d5c2d50a0a 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/README.md +++ b/packages/opentelemetry-exporter-collector/src/platform/node/README.md @@ -44,3 +44,10 @@ the latest sha when this guide was written is `b54688569186e0b862bf7462a983ccf2c ``` 9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one + +10. After upgrading protos you should regenerate proto files for js. To do that go run +```shell script +npm run generate:http-proto +``` +After this command it should generate a new js files in folder "generated". +Make sure it compiles correctly. diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts new file mode 100644 index 0000000000..30f7e9e4ff --- /dev/null +++ b/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts @@ -0,0 +1,313 @@ +/* + * 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. + */ + +/* eslint @typescript-eslint/no-var-requires: 0 */ + +// import * as pgTrace from '../../../generated/opentelemetry/proto/trace/v1/trace'; +// import * as pgResource from '../../../generated/opentelemetry/proto/resource/v1/resource'; +// import * as pgCommon from '../../../generated/opentelemetry/proto/common/v1/common'; +// import * as pgCollector from '../../../generated/opentelemetry/proto/collector/trace/v1/trace_service'; +const pgTrace = require('../../../generated/opentelemetry/proto/trace/v1/trace_pb'); +const pgResource = require('../../../generated/opentelemetry/proto/resource/v1/resource_pb'); +const pgCommon = require('../../../generated/opentelemetry/proto/common/v1/common_pb'); +const pgCollector = require('../../../generated/opentelemetry/proto/collector/trace/v1/trace_service_pb'); + +import { + Attributes, + Link, + SpanKind, + Status, + TimedEvent, + TraceState, +} from '@opentelemetry/api'; +import * as core from '@opentelemetry/core'; +import { Resource } from '@opentelemetry/resources'; +import { ReadableSpan } from '@opentelemetry/tracing'; +import { CollectorTraceExporterBase } from '../../CollectorTraceExporterBase'; +import { groupSpansByResourceAndLibrary } from '../../transform'; +import { COLLECTOR_SPAN_KIND_MAPPING, opentelemetryProto } from '../../types'; +import ValueType = opentelemetryProto.common.v1.ValueType; +import { InstrumentationLibrary } from '@opentelemetry/core'; +import { CollectorExporterConfigNode } from './types'; + +/** + * Converts attributes + * @param attributes + */ +export function toCollectorAttributes(attributes: Attributes) { + //: pgCommon.opentelemetry.proto.common.v1.AttributeKeyValue[] { + return Object.keys(attributes).map(key => { + return toCollectorAttributeKeyValue(key, attributes[key]); + }); +} + +/** + * Converts key and value to AttributeKeyValue + * @param value event value + */ +export function toCollectorAttributeKeyValue(key: string, value: unknown) { + //: pgCommon.opentelemetry.proto.common.v1.AttributeKeyValue { + const attributeKeyValue = new pgCommon.AttributeKeyValue(); + attributeKeyValue.setKey(key); + + if (typeof value === 'string') { + attributeKeyValue.setStringValue(value); + attributeKeyValue.setType(ValueType.STRING); + } else if (typeof value === 'boolean') { + attributeKeyValue.setBoolValue(value); + attributeKeyValue.setType(ValueType.BOOL); + } else if (typeof value === 'number') { + // all numbers will be treated as double + attributeKeyValue.setDoubleValue(value); + attributeKeyValue.setType(ValueType.DOUBLE); + } + return attributeKeyValue; +} + +/** + * + * Converts events + * @param events array of events + */ +export function toCollectorEvents(timedEvents: TimedEvent[]) { + //: pgTrace.opentelemetry.proto.trace.v1.Span.Event[] { + return timedEvents.map(timedEvent => { + const timeUnixNano = core.hrTimeToNanoseconds(timedEvent.time); + const name = timedEvent.name; + const attributes = toCollectorAttributes(timedEvent.attributes || {}); + const droppedAttributesCount = 0; + const protoEvent = new pgTrace.Span.Event(); + protoEvent.setTimeUnixNano(timeUnixNano); + protoEvent.setName(name); + protoEvent.setAttributesList(attributes); + protoEvent.setDroppedAttributesCount(droppedAttributesCount); + + return protoEvent; + }); +} + +/** + * Converts links + * @param span + */ +export function toCollectorLinks(span: ReadableSpan) { + //: pgTrace.opentelemetry.proto.trace.v1.Span.Link[] { + return span.links.map((link: Link) => { + const protoLink = new pgTrace.Span.Link(); + protoLink.setTraceId(hexToBuffer(link.context.traceId)); + protoLink.setSpanId(hexToBuffer(link.context.spanId)); + protoLink.setAttributesList(toCollectorAttributes(link.attributes || {})); + protoLink.setDroppedAttributesCount(0); + return protoLink; + }); +} + +export function toCollectorStatus(status: Status) { + //: pgTrace.opentelemetry.proto.trace.v1.Status { + const protoStatus = new pgTrace.Status(); + protoStatus.setCode(status.code); + protoStatus.setMessage(status.message); + return protoStatus; +} + +/** + * Converts span + * @param span + */ +export function toCollectorSpan(span: ReadableSpan) { + //: pgTrace.opentelemetry.proto.trace.v1.Span { + const protoSpan = new pgTrace.Span(); + + protoSpan.setTraceId(hexToBuffer(span.spanContext.traceId)); + protoSpan.setSpanId(hexToBuffer(span.spanContext.spanId)); + if (span.parentSpanId) { + protoSpan.setParentSpanId(hexToBuffer(span.parentSpanId)); + } + protoSpan.setTraceState(toCollectorTraceState(span.spanContext.traceState)); + protoSpan.setName(span.name); + protoSpan.setKind(toCollectorKind(span.kind)); + protoSpan.setStartTimeUnixNano(core.hrTimeToNanoseconds(span.startTime)); + protoSpan.setEndTimeUnixNano(core.hrTimeToNanoseconds(span.endTime)); + + protoSpan.setAttributesList(toCollectorAttributes(span.attributes)); + protoSpan.setDroppedAttributesCount(0); + + protoSpan.setEventsList(toCollectorEvents(span.events)); + protoSpan.setDroppedEventsCount(0); + + protoSpan.setStatus(toCollectorStatus(span.status)); + + protoSpan.setLinksList(toCollectorLinks(span)); + protoSpan.setDroppedLinksCount(0); + + return protoSpan; + + // return new pgTrace.Span({ + // trace_id: hexToBuffer(span.spanContext.traceId), + // span_id: hexToBuffer(span.spanContext.spanId), + // parent_span_id: span.parentSpanId + // ? hexToBuffer(span.parentSpanId) + // : undefined, + // trace_state: toCollectorTraceState(span.spanContext.traceState), + // name: span.name, + // kind: toCollectorKind(span.kind), + // start_time_unix_nano: core.hrTimeToNanoseconds(span.startTime), + // end_time_unix_nano: core.hrTimeToNanoseconds(span.endTime), + // attributes: toCollectorAttributes(span.attributes), + // dropped_attributes_count: 0, + // events: toCollectorEvents(span.events), + // dropped_events_count: 0, + // status: toCollectorStatus(span.status), + // links: toCollectorLinks(span), + // dropped_links_count: 0, + // }); +} + +/** + * Converts resource + * @param resource + * @param additionalAttributes + */ +export function toCollectorResource( + resource?: Resource, + additionalAttributes: { [key: string]: unknown } = {} +) { + //: pgResource.opentelemetry.proto.resource.v1.Resource { + // pgResource.opentelemetry.proto.resource.v1.Resource + // pgTrace.opentelemetry.proto. trace.v1.ResourceSpans + const attr = Object.assign( + {}, + additionalAttributes, + resource ? resource.labels : {} + ); + const resourceProto = new pgResource.Resource(); + const attributes = toCollectorAttributes(attr); + resourceProto.setAttributesList(attributes); + resourceProto.setDroppedAttributesCount(0); + return resourceProto; +} + +/** + * Converts span kind + * @param kind + */ +export function toCollectorKind(kind: SpanKind) { + //: pgTrace.opentelemetry.proto.trace.v1.Span.SpanKind { + const collectorKind = COLLECTOR_SPAN_KIND_MAPPING[kind]; + return typeof collectorKind === 'number' + ? collectorKind + : opentelemetryProto.trace.v1.Span.SpanKind.SPAN_KIND_UNSPECIFIED; +} + +/** + * Converts traceState + * @param traceState + */ +export function toCollectorTraceState(traceState?: TraceState) { + //: string | undefined { + if (!traceState) { + return undefined; + } + return traceState.serialize(); +} + +/** + * Prepares trace service request to be sent to collector + * @param spans spans + * @param collectorTraceExporter + * @param [name] Instrumentation Library Name + */ +export function toCollectorExportTraceServiceRequest< + T extends CollectorExporterConfigNode +>( + spans: ReadableSpan[], + collectorTraceExporter: CollectorTraceExporterBase +) { + //: pgCollector.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest { + const groupedSpans: Map< + Resource, + Map + > = groupSpansByResourceAndLibrary(spans); + + const additionalAttributes = Object.assign( + {}, + collectorTraceExporter.attributes || {}, + { + 'service.name': collectorTraceExporter.serviceName, + } + ); + + const exportTraceServiceRequest = new pgCollector.ExportTraceServiceRequest(); + const resourceSpans = toCollectorResourceSpans( + groupedSpans, + additionalAttributes + ); + exportTraceServiceRequest.setResourceSpansList(resourceSpans); + + return exportTraceServiceRequest; +} + +function toCollectorInstrumentationLibrarySpans( + instrumentationLibrary: InstrumentationLibrary, + spans: ReadableSpan[] +) { + //: pgTrace.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans { + const instrumentationLibrarySpans = new pgTrace.InstrumentationLibrarySpans(); + + const protoSpans = spans.map(toCollectorSpan); + instrumentationLibrarySpans.setSpansList(protoSpans); + + const protoInstrumentationLibrary = new pgCommon.InstrumentationLibrary(); + protoInstrumentationLibrary.setName(instrumentationLibrary.name); + protoInstrumentationLibrary.setVersion(instrumentationLibrary.version); + instrumentationLibrarySpans.setInstrumentationLibrary( + protoInstrumentationLibrary + ); + + return instrumentationLibrarySpans; +} + +function toCollectorResourceSpans( + groupedSpans: Map>, + baseAttributes: Attributes +) { + //: pgTrace.opentelemetry.proto.trace.v1.ResourceSpans[] { + return Array.from(groupedSpans, ([resource, libSpans]) => { + const resourceSpans = new pgTrace.ResourceSpans(); + const res = toCollectorResource(resource, baseAttributes); + resourceSpans.setResource(res); + const instrumentationLibrarySpans = Array.from( + libSpans, + ([instrumentationLibrary, spans]) => + toCollectorInstrumentationLibrarySpans(instrumentationLibrary, spans) + ); + resourceSpans.setInstrumentationLibrarySpansList( + instrumentationLibrarySpans + ); + return resourceSpans; + }); +} + +function hexToBuffer(hexStr: string): Uint8Array { + const hexStrLen = hexStr.length; + let hexAsciiCharsStr = ''; + for (let i = 0; i < hexStrLen; i += 2) { + const hexPair = hexStr.substring(i, i + 2); + const hexVal = parseInt(hexPair, 16); + hexAsciiCharsStr += String.fromCharCode(hexVal); + } + return Buffer.from(hexAsciiCharsStr, 'ascii'); +} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/util.ts b/packages/opentelemetry-exporter-collector/src/platform/node/util.ts index 9ad59d5690..4629aab2e3 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/util.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/util.ts @@ -13,6 +13,65 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +import * as url from 'url'; +import * as http from 'http'; +import * as https from 'https'; +import * as collectorTypes from '../../types'; +import { CollectorTraceExporter } from './CollectorTraceExporter'; + export function removeProtocol(url: string): string { return url.replace(/^https?:\/\//, ''); } + +/** + * Sends data using http + * @param collector + * @param data + * @param contentType + * @param onSuccess + * @param onError + */ +export function sendDataUsingHttp( + collector: CollectorTraceExporter, + data: string | Buffer, + contentType: string, + onSuccess: () => void, + onError: (error: collectorTypes.CollectorExporterError) => void +): void { + const parsedUrl = new url.URL(collector.url); + + const options = { + hostname: parsedUrl.hostname, + port: parsedUrl.port, + path: parsedUrl.pathname, + method: 'POST', + headers: { + 'Content-Length': Buffer.byteLength(data), + 'Content-Type': contentType, + ...collector.headers, + }, + }; + + const request = parsedUrl.protocol === 'http:' ? http.request : https.request; + const req = request(options, (res: http.IncomingMessage) => { + if (res.statusCode && res.statusCode < 299) { + collector.logger.debug(`statusCode: ${res.statusCode}`); + onSuccess(); + } else { + collector.logger.error(`statusCode: ${res.statusCode}`); + onError({ + code: res.statusCode, + message: res.statusMessage, + }); + } + }); + + req.on('error', (error: Error) => { + collector.logger.error('error', error.message); + onError({ + message: error.message, + }); + }); + req.write(data); + req.end(); +} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts index a37638ac12..7badf20bd5 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts @@ -14,15 +14,12 @@ * limitations under the License. */ -import * as url from 'url'; -import * as http from 'http'; -import * as https from 'https'; - import { ReadableSpan } from '@opentelemetry/tracing'; import * as collectorTypes from '../../types'; -import { toCollectorExportTraceServiceRequest } from '../../transform'; import { CollectorTraceExporter } from './CollectorTraceExporter'; +import { toCollectorExportTraceServiceRequest } from '../../transform'; import { CollectorExporterConfigNode } from './types'; +import { sendDataUsingHttp } from './util'; export const DEFAULT_COLLECTOR_URL_JSON = 'http://localhost:55680/v1/trace'; @@ -33,6 +30,13 @@ export function onInitWithJson( // nothing to be done for json yet } +/** + * Send spans using json over http + * @param collector + * @param spans + * @param onSuccess + * @param onError + */ export function sendSpansUsingJson( collector: CollectorTraceExporter, spans: ReadableSpan[], @@ -45,40 +49,12 @@ export function sendSpansUsingJson( ); const body = JSON.stringify(exportTraceServiceRequest); - const parsedUrl = new url.URL(collector.url); - const options = { - hostname: parsedUrl.hostname, - port: parsedUrl.port, - path: parsedUrl.pathname, - method: 'POST', - headers: { - 'Content-Length': Buffer.byteLength(body), - 'Content-Type': 'application/json', - ...collector.headers, - }, - }; - - const request = parsedUrl.protocol === 'http:' ? http.request : https.request; - const req = request(options, (res: http.IncomingMessage) => { - if (res.statusCode && res.statusCode < 299) { - collector.logger.debug(`statusCode: ${res.statusCode}`); - onSuccess(); - } else { - collector.logger.error(`statusCode: ${res.statusCode}`); - onError({ - code: res.statusCode, - message: res.statusMessage, - }); - } - }); - - req.on('error', (error: Error) => { - collector.logger.error('error', error.message); - onError({ - message: error.message, - }); - }); - req.write(body); - req.end(); + return sendDataUsingHttp( + collector, + body, + 'application/json', + onSuccess, + onError + ); } diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts new file mode 100644 index 0000000000..e4777cbaba --- /dev/null +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts @@ -0,0 +1,61 @@ +/* + * 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 { ReadableSpan } from '@opentelemetry/tracing'; +import * as collectorTypes from '../../types'; +import { CollectorTraceExporter } from './CollectorTraceExporter'; +import { toCollectorExportTraceServiceRequest } from './transformSpansProto'; +import { CollectorExporterConfigNode } from './types'; +import { sendDataUsingHttp } from './util'; + +export const DEFAULT_COLLECTOR_URL_JSON_PROTO = + 'http://localhost:55680/v1/trace'; + +export function onInitWithJsonProto( + _collector: CollectorTraceExporter, + _config: CollectorExporterConfigNode +): void { + // nothing to be done for json proto yet +} + +/** + * Send spans using proto over http + * @param collector + * @param spans + * @param onSuccess + * @param onError + */ +export function sendSpansUsingJsonProto( + collector: CollectorTraceExporter, + spans: ReadableSpan[], + onSuccess: () => void, + onError: (error: collectorTypes.CollectorExporterError) => void +): void { + const exportTraceServiceRequest = toCollectorExportTraceServiceRequest( + spans, + collector + ); + + const body = exportTraceServiceRequest.serializeBinary(); + + return sendDataUsingHttp( + collector, + Buffer.from(body), + 'application/x-protobuf', + onSuccess, + onError + ); +} diff --git a/packages/opentelemetry-exporter-collector/test/node/CollectorTraceExporter.test.ts b/packages/opentelemetry-exporter-collector/test/node/CollectorTraceExporter.test.ts index 91e89fc02f..9cadd1574c 100644 --- a/packages/opentelemetry-exporter-collector/test/node/CollectorTraceExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/node/CollectorTraceExporter.test.ts @@ -168,7 +168,7 @@ const testCollectorExporter = (params: TestParams) => protocolNode: CollectorProtocolNode.HTTP_JSON, }); const args = spyLoggerWarn.args[0]; - assert.strictEqual(args[0], 'Metadata cannot be set when using json'); + assert.strictEqual(args[0], 'Metadata cannot be set when using http'); }); }); diff --git a/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts b/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts new file mode 100644 index 0000000000..e89ce0d385 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts @@ -0,0 +1,383 @@ +/* + * 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 { Attributes, TimedEvent } from '@opentelemetry/api'; +import * as assert from 'assert'; +import * as transform from '../../src/platform/node/transformSpansProto'; +import { opentelemetryProto } from '../../src/types'; +import { mockedReadableSpan } from '../helper'; +import { Resource } from '@opentelemetry/resources'; + +describe('transform - spans proto', () => { + describe('toCollectorAttributes', () => { + it('should convert attribute string', () => { + const attributes: Attributes = { + foo: 'bar', + }; + assert.deepStrictEqual( + transform.toCollectorAttributes(attributes)[0].toObject(), + { + key: 'foo', + type: 0, + stringValue: 'bar', + intValue: 0, + doubleValue: 0, + boolValue: false, + } + ); + }); + + it('should convert attribute integer', () => { + const attributes: Attributes = { + foo: 13, + }; + assert.deepStrictEqual( + transform.toCollectorAttributes(attributes)[0].toObject(), + { + key: 'foo', + type: 2, + stringValue: '', + intValue: 0, + doubleValue: 13, + boolValue: false, + } + ); + }); + + it('should convert attribute boolean', () => { + const attributes: Attributes = { + foo: true, + }; + assert.deepStrictEqual( + transform.toCollectorAttributes(attributes)[0].toObject(), + { + key: 'foo', + type: 3, + stringValue: '', + intValue: 0, + doubleValue: 0, + boolValue: true, + } + ); + }); + + it('should convert attribute double', () => { + const attributes: Attributes = { + foo: 1.34, + }; + assert.deepStrictEqual( + transform.toCollectorAttributes(attributes)[0].toObject(), + { + key: 'foo', + type: 2, + stringValue: '', + intValue: 0, + doubleValue: 1.34, + boolValue: false, + } + ); + }); + }); + + describe('toCollectorEvents', () => { + it('should convert events to otc events', () => { + const events: TimedEvent[] = [ + { name: 'foo', time: [123, 123], attributes: { a: 'b' } }, + { + name: 'foo2', + time: [321, 321], + attributes: { c: 'd' }, + }, + ]; + const protoEvents = transform.toCollectorEvents(events); + const event1 = protoEvents[0].toObject(); + const event2 = protoEvents[1].toObject(); + assert.deepStrictEqual(event1, { + timeUnixNano: 123000000123, + name: 'foo', + attributesList: [ + { + key: 'a', + type: 0, + stringValue: 'b', + intValue: 0, + doubleValue: 0, + boolValue: false, + }, + ], + droppedAttributesCount: 0, + }); + assert.deepStrictEqual(event2, { + timeUnixNano: 321000000321, + name: 'foo2', + attributesList: [ + { + key: 'c', + type: 0, + stringValue: 'd', + intValue: 0, + doubleValue: 0, + boolValue: false, + }, + ], + droppedAttributesCount: 0, + }); + }); + }); + + describe('toCollectorSpan', () => { + const span = transform.toCollectorSpan(mockedReadableSpan).toObject(); + it('should convert attributes', () => { + assert.deepStrictEqual(span.attributesList, [ + { + key: 'component', + type: 0, + stringValue: 'document-load', + intValue: 0, + doubleValue: 0, + boolValue: false, + }, + ]); + }); + it('should convert events', () => { + assert.deepStrictEqual(span.eventsList, [ + { + timeUnixNano: 1574120165429803000, + name: 'fetchStart', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165429803000, + name: 'domainLookupStart', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165429803000, + name: 'domainLookupEnd', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165429803000, + name: 'connectStart', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165429803000, + name: 'connectEnd', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165435513000, + name: 'requestStart', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165436923100, + name: 'responseStart', + attributesList: [], + droppedAttributesCount: 0, + }, + { + timeUnixNano: 1574120165438688000, + name: 'responseEnd', + attributesList: [], + droppedAttributesCount: 0, + }, + ]); + }); + it('should convert links', () => { + assert.deepStrictEqual(span.linksList, [ + { + traceId: 'HxAI3I4nDoXECg18OTmyeA==', + spanId: 'eKiRUJiGQ4g=', + traceState: '', + attributesList: [ + { + key: 'component', + type: 0, + stringValue: 'document-load', + intValue: 0, + doubleValue: 0, + boolValue: false, + }, + ], + droppedAttributesCount: 0, + }, + ]); + }); + it('should convert trace id', () => { + assert.deepStrictEqual( + span.traceId, + 'HxAI3I4nDoXECg18OTmyeA==', + 'traceId is wrong' + ); + assert.deepStrictEqual(span.spanId, 'XhByYfZPpT4=', 'spanId is wrong'); + assert.deepStrictEqual( + span.parentSpanId, + 'eKiRUJiGQ4g=', + 'parentIdArr is wrong' + ); + assert.strictEqual(span.name, 'documentFetch', 'name is wrong'); + assert.strictEqual( + span.kind, + opentelemetryProto.trace.v1.Span.SpanKind.INTERNAL, + 'kind is wrong' + ); + assert.strictEqual( + span.startTimeUnixNano, + 1574120165429803008, + 'startTimeUnixNano is wrong' + ); + assert.strictEqual( + span.endTimeUnixNano, + 1574120165438688000, + 'endTimeUnixNano is wrong' + ); + assert.strictEqual( + span.droppedAttributesCount, + 0, + 'droppedAttributesCount is wrong' + ); + assert.strictEqual( + span.droppedEventsCount, + 0, + 'droppedEventsCount is wrong' + ); + assert.strictEqual( + span.droppedLinksCount, + 0, + 'droppedLinksCount is wrong' + ); + assert.deepStrictEqual( + span.status, + { code: 0, message: '' }, + 'status is' + ' wrong' + ); + }); + it('should convert span id', () => { + assert.deepStrictEqual(span.spanId, 'XhByYfZPpT4=', 'spanId is wrong'); + }); + it('should convert parent id', () => { + assert.deepStrictEqual( + span.parentSpanId, + 'eKiRUJiGQ4g=', + 'parentIdArr is wrong' + ); + }); + it('should convert name', () => { + assert.strictEqual(span.name, 'documentFetch', 'name is wrong'); + }); + it('should convert kind', () => { + assert.strictEqual( + span.kind, + opentelemetryProto.trace.v1.Span.SpanKind.INTERNAL, + 'kind is wrong' + ); + }); + it('should convert start time', () => { + assert.strictEqual( + span.startTimeUnixNano, + 1574120165429803008, + 'startTimeUnixNano is wrong' + ); + }); + it('should convert end time', () => { + assert.strictEqual( + span.endTimeUnixNano, + 1574120165438688000, + 'endTimeUnixNano is wrong' + ); + }); + it('should convert droppedAttributesCount', () => { + assert.strictEqual( + span.droppedAttributesCount, + 0, + 'droppedAttributesCount is wrong' + ); + }); + + it('should convert droppedEventsCount', () => { + assert.strictEqual( + span.droppedEventsCount, + 0, + 'droppedEventsCount is wrong' + ); + }); + + it('should convert droppedLinksCount', () => { + assert.strictEqual( + span.droppedLinksCount, + 0, + 'droppedLinksCount is wrong' + ); + }); + + it('should convert status', () => { + assert.deepStrictEqual( + span.status, + { code: 0, message: '' }, + 'status is' + ' wrong' + ); + }); + }); + + describe('toCollectorResource', () => { + it('should convert resource', () => { + const resource = transform.toCollectorResource( + new Resource({ + service: 'ui', + version: 1.0, + success: true, + }) + ); + assert.deepStrictEqual(resource.toObject(), { + attributesList: [ + { + key: 'service', + type: 0, + stringValue: 'ui', + intValue: 0, + doubleValue: 0, + boolValue: false, + }, + { + key: 'version', + type: 2, + stringValue: '', + intValue: 0, + doubleValue: 1, + boolValue: false, + }, + { + key: 'success', + type: 3, + stringValue: '', + intValue: 0, + doubleValue: 0, + boolValue: true, + }, + ], + droppedAttributesCount: 0, + }); + }); + }); +}); diff --git a/packages/opentelemetry-exporter-collector/tsconfig.json b/packages/opentelemetry-exporter-collector/tsconfig.json index a2042cd68b..8d3779eda9 100644 --- a/packages/opentelemetry-exporter-collector/tsconfig.json +++ b/packages/opentelemetry-exporter-collector/tsconfig.json @@ -5,6 +5,7 @@ "outDir": "build" }, "include": [ + "generated/**/*.js", "src/**/*.ts", "test/**/*.ts" ] From 6638c32b5f8f4ecfb9a3b1acc8a61c32b2257a81 Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Fri, 10 Jul 2020 14:44:05 +0200 Subject: [PATCH 02/10] chore: lint --- .../src/platform/node/README.md | 2 ++ .../src/platform/node/transformSpansProto.ts | 20 ------------------- 2 files changed, 2 insertions(+), 20 deletions(-) diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/README.md b/packages/opentelemetry-exporter-collector/src/platform/node/README.md index d5c2d50a0a..4dec5ba87b 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/README.md +++ b/packages/opentelemetry-exporter-collector/src/platform/node/README.md @@ -46,8 +46,10 @@ the latest sha when this guide was written is `b54688569186e0b862bf7462a983ccf2c 9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one 10. After upgrading protos you should regenerate proto files for js. To do that go run + ```shell script npm run generate:http-proto ``` + After this command it should generate a new js files in folder "generated". Make sure it compiles correctly. diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts index 30f7e9e4ff..7d96424658 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts @@ -154,26 +154,6 @@ export function toCollectorSpan(span: ReadableSpan) { protoSpan.setDroppedLinksCount(0); return protoSpan; - - // return new pgTrace.Span({ - // trace_id: hexToBuffer(span.spanContext.traceId), - // span_id: hexToBuffer(span.spanContext.spanId), - // parent_span_id: span.parentSpanId - // ? hexToBuffer(span.parentSpanId) - // : undefined, - // trace_state: toCollectorTraceState(span.spanContext.traceState), - // name: span.name, - // kind: toCollectorKind(span.kind), - // start_time_unix_nano: core.hrTimeToNanoseconds(span.startTime), - // end_time_unix_nano: core.hrTimeToNanoseconds(span.endTime), - // attributes: toCollectorAttributes(span.attributes), - // dropped_attributes_count: 0, - // events: toCollectorEvents(span.events), - // dropped_events_count: 0, - // status: toCollectorStatus(span.status), - // links: toCollectorLinks(span), - // dropped_links_count: 0, - // }); } /** From dbdd707258eb6800457dac197020fe7b048d13ee Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Fri, 10 Jul 2020 14:53:21 +0200 Subject: [PATCH 03/10] chore: lint --- .../src/platform/node/CollectorTraceExporter.ts | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts index 936ffc7dd1..ea2e93687b 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts @@ -129,9 +129,7 @@ export class CollectorTraceExporter extends CollectorTraceExporterBase< if (!config.url) { if (config.protocolNode === CollectorProtocolNode.HTTP_JSON) { return DEFAULT_COLLECTOR_URL_JSON; - } else if ( - config.protocolNode === CollectorProtocolNode.HTTP_PROTO - ) { + } else if (config.protocolNode === CollectorProtocolNode.HTTP_PROTO) { return DEFAULT_COLLECTOR_URL_JSON_PROTO; } else { return DEFAULT_COLLECTOR_URL_GRPC; From 32a01c558dc7581c329e6d261ced1ed300ae0d6b Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Fri, 10 Jul 2020 14:57:37 +0200 Subject: [PATCH 04/10] chore: fixing transport type in example --- examples/collector-exporter-node/start.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/collector-exporter-node/start.js b/examples/collector-exporter-node/start.js index dd24a94c7d..138b6b41ec 100644 --- a/examples/collector-exporter-node/start.js +++ b/examples/collector-exporter-node/start.js @@ -9,7 +9,7 @@ const exporter = new CollectorTraceExporter({ // headers: { // foo: 'bar' // }, - protocolNode: CollectorProtocolNode.HTTP_JSON_PROTO, + protocolNode: CollectorProtocolNode.HTTP_PROTO, // protocolNode: CollectorProtocolNode.HTTP_JSON, }); From 0b7dc817e76f727f4097596cc7eba794deefab5d Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Fri, 10 Jul 2020 15:05:47 +0200 Subject: [PATCH 05/10] chore: adding generated to files in package.json --- packages/opentelemetry-exporter-collector/package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/opentelemetry-exporter-collector/package.json b/packages/opentelemetry-exporter-collector/package.json index 9edc6d7fbc..673ef3dba2 100644 --- a/packages/opentelemetry-exporter-collector/package.json +++ b/packages/opentelemetry-exporter-collector/package.json @@ -48,6 +48,7 @@ "build/src/**/*.js.map", "build/src/**/*.d.ts", "build/src/**/*.proto", + "build/generated/**/*.js", "doc", "LICENSE", "README.md" From 11c5a5618bb855e7dfab958bf259d7ed4964eadd Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Mon, 13 Jul 2020 21:28:24 +0200 Subject: [PATCH 06/10] chore: adding more info about protoc --- .../src/platform/node/README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/README.md b/packages/opentelemetry-exporter-collector/src/platform/node/README.md index 4dec5ba87b..5827349a43 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/README.md +++ b/packages/opentelemetry-exporter-collector/src/platform/node/README.md @@ -45,7 +45,8 @@ the latest sha when this guide was written is `b54688569186e0b862bf7462a983ccf2c 9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one -10. After upgrading protos you should regenerate proto files for js. To do that go run +10. After upgrading protos you should regenerate proto files for js. +**You need to have protocol buffers installed to be able to generate them**. ```shell script npm run generate:http-proto From bfeaec7af89953b2e1912fc5ab982788e907de96 Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Tue, 14 Jul 2020 00:21:50 +0200 Subject: [PATCH 07/10] chore: replacing google-protobuf with protobufjs --- .nycrc | 1 - .../opentelemetry-exporter-collector/gen.sh | 13 - .../collector/trace/v1/trace_service_pb.js | 323 --- .../proto/common/v1/common_pb.js | 692 ------ .../proto/resource/v1/resource_pb.js | 229 -- .../opentelemetry/proto/trace/v1/trace_pb.js | 2067 ----------------- .../package.json | 8 +- .../src/platform/node/README.md | 8 - .../src/platform/node/transformSpansProto.ts | 293 --- .../src/platform/node/utilWithJsonProto.ts | 49 +- .../test/helper.ts | 131 ++ .../node/CollectorExporterWithProto.test.ts | 188 ++ .../test/node/transformSpansProto.test.ts | 383 --- .../tsconfig.json | 1 - 14 files changed, 361 insertions(+), 4025 deletions(-) delete mode 100755 packages/opentelemetry-exporter-collector/gen.sh delete mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js delete mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js delete mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js delete mode 100644 packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js delete mode 100644 packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts create mode 100644 packages/opentelemetry-exporter-collector/test/node/CollectorExporterWithProto.test.ts delete mode 100644 packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts diff --git a/.nycrc b/.nycrc index 53a2f2262d..47b8c170df 100644 --- a/.nycrc +++ b/.nycrc @@ -5,7 +5,6 @@ "exclude": [ "**/*.d.ts", "build/**/*.*", - "generated/**/*.*", "src/index.ts", "src/platform/**/index.ts", "src/platform/browser/*.ts", diff --git a/packages/opentelemetry-exporter-collector/gen.sh b/packages/opentelemetry-exporter-collector/gen.sh deleted file mode 100755 index 7404879bb9..0000000000 --- a/packages/opentelemetry-exporter-collector/gen.sh +++ /dev/null @@ -1,13 +0,0 @@ -clear -git submodule sync --recursive -git submodule update --init --recursive - -OUT_DIR="./generated" - -protoc \ - --js_out="import_style=commonjs,binary:${OUT_DIR}" \ - --proto_path="src/platform/node/protos/" \ - opentelemetry/proto/common/v1/common.proto \ - opentelemetry/proto/resource/v1/resource.proto \ - opentelemetry/proto/trace/v1/trace.proto \ - opentelemetry/proto/collector/trace/v1/trace_service.proto \ diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js deleted file mode 100644 index 606e2dd104..0000000000 --- a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js +++ /dev/null @@ -1,323 +0,0 @@ -// source: opentelemetry/proto/collector/trace/v1/trace_service.proto -// source: opentelemetry/proto/collector/trace/v1/trace_service.proto -/** - * @fileoverview - * @enhanceable - * @suppress {messageConventions} JS Compiler reports an error if a variable or - * field starts with 'MSG_' and isn't a translatable message. - * @public - */ -// GENERATED CODE -- DO NOT EDIT! - -var jspb = require('google-protobuf'); -var goog = jspb; -var global = Function('return this')(); - -var opentelemetry_proto_trace_v1_trace_pb = require('../../../../../opentelemetry/proto/trace/v1/trace_pb.js'); -goog.object.extend(proto, opentelemetry_proto_trace_v1_trace_pb); -goog.exportSymbol('proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest', null, global); -goog.exportSymbol('proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse', null, global); -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.displayName = 'proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.displayName = 'proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse'; -} - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.repeatedFields_ = [1]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.toObject = function(includeInstance, msg) { - var f, obj = { - resourceSpansList: jspb.Message.toObjectList(msg.getResourceSpansList(), - opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.toObject, includeInstance) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest; - return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = new opentelemetry_proto_trace_v1_trace_pb.ResourceSpans; - reader.readMessage(value,opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.deserializeBinaryFromReader); - msg.addResourceSpans(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getResourceSpansList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 1, - f, - opentelemetry_proto_trace_v1_trace_pb.ResourceSpans.serializeBinaryToWriter - ); - } -}; - - -/** - * repeated opentelemetry.proto.trace.v1.ResourceSpans resource_spans = 1; - * @return {!Array} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.getResourceSpansList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_trace_v1_trace_pb.ResourceSpans, 1)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} returns this -*/ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.setResourceSpansList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.addResourceSpans = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.opentelemetry.proto.trace.v1.ResourceSpans, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} returns this - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.prototype.clearResourceSpansList = function() { - return this.setResourceSpansList([]); -}; - - - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.toObject = function(includeInstance, msg) { - var f, obj = { - - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse; - return proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; -}; - - -goog.object.extend(exports, proto.opentelemetry.proto.collector.trace.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js deleted file mode 100644 index 796ad90f6a..0000000000 --- a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/common/v1/common_pb.js +++ /dev/null @@ -1,692 +0,0 @@ -// source: opentelemetry/proto/common/v1/common.proto -/** - * @fileoverview - * @enhanceable - * @suppress {messageConventions} JS Compiler reports an error if a variable or - * field starts with 'MSG_' and isn't a translatable message. - * @public - */ -// GENERATED CODE -- DO NOT EDIT! - -var jspb = require('google-protobuf'); -var goog = jspb; -var global = Function('return this')(); - -goog.exportSymbol('proto.opentelemetry.proto.common.v1.AttributeKeyValue', null, global); -goog.exportSymbol('proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType', null, global); -goog.exportSymbol('proto.opentelemetry.proto.common.v1.InstrumentationLibrary', null, global); -goog.exportSymbol('proto.opentelemetry.proto.common.v1.StringKeyValue', null, global); -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.opentelemetry.proto.common.v1.AttributeKeyValue, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.common.v1.AttributeKeyValue.displayName = 'proto.opentelemetry.proto.common.v1.AttributeKeyValue'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.common.v1.StringKeyValue = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.opentelemetry.proto.common.v1.StringKeyValue, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.common.v1.StringKeyValue.displayName = 'proto.opentelemetry.proto.common.v1.StringKeyValue'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.opentelemetry.proto.common.v1.InstrumentationLibrary, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.common.v1.InstrumentationLibrary.displayName = 'proto.opentelemetry.proto.common.v1.InstrumentationLibrary'; -} - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.common.v1.AttributeKeyValue.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.toObject = function(includeInstance, msg) { - var f, obj = { - key: jspb.Message.getFieldWithDefault(msg, 1, ""), - type: jspb.Message.getFieldWithDefault(msg, 2, 0), - stringValue: jspb.Message.getFieldWithDefault(msg, 3, ""), - intValue: jspb.Message.getFieldWithDefault(msg, 4, 0), - doubleValue: jspb.Message.getFloatingPointFieldWithDefault(msg, 5, 0.0), - boolValue: jspb.Message.getBooleanFieldWithDefault(msg, 6, false) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.common.v1.AttributeKeyValue; - return proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 2: - var value = /** @type {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} */ (reader.readEnum()); - msg.setType(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setStringValue(value); - break; - case 4: - var value = /** @type {number} */ (reader.readInt64()); - msg.setIntValue(value); - break; - case 5: - var value = /** @type {number} */ (reader.readDouble()); - msg.setDoubleValue(value); - break; - case 6: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setBoolValue(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.common.v1.AttributeKeyValue.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getType(); - if (f !== 0.0) { - writer.writeEnum( - 2, - f - ); - } - f = message.getStringValue(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getIntValue(); - if (f !== 0) { - writer.writeInt64( - 4, - f - ); - } - f = message.getDoubleValue(); - if (f !== 0.0) { - writer.writeDouble( - 5, - f - ); - } - f = message.getBoolValue(); - if (f) { - writer.writeBool( - 6, - f - ); - } -}; - - -/** - * @enum {number} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType = { - STRING: 0, - INT: 1, - DOUBLE: 2, - BOOL: 3 -}; - -/** - * optional string key = 1; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional ValueType type = 2; - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getType = function() { - return /** @type {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); -}; - - -/** - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue.ValueType} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setType = function(value) { - return jspb.Message.setProto3EnumField(this, 2, value); -}; - - -/** - * optional string string_value = 3; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getStringValue = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setStringValue = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional int64 int_value = 4; - * @return {number} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getIntValue = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setIntValue = function(value) { - return jspb.Message.setProto3IntField(this, 4, value); -}; - - -/** - * optional double double_value = 5; - * @return {number} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getDoubleValue = function() { - return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 5, 0.0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setDoubleValue = function(value) { - return jspb.Message.setProto3FloatField(this, 5, value); -}; - - -/** - * optional bool bool_value = 6; - * @return {boolean} - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.getBoolValue = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 6, false)); -}; - - -/** - * @param {boolean} value - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.AttributeKeyValue.prototype.setBoolValue = function(value) { - return jspb.Message.setProto3BooleanField(this, 6, value); -}; - - - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.common.v1.StringKeyValue.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.toObject = function(includeInstance, msg) { - var f, obj = { - key: jspb.Message.getFieldWithDefault(msg, 1, ""), - value: jspb.Message.getFieldWithDefault(msg, 2, "") - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.common.v1.StringKeyValue; - return proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setValue(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.common.v1.StringKeyValue.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.common.v1.StringKeyValue} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getValue(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * optional string key = 1; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string value = 2; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.getValue = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.StringKeyValue} returns this - */ -proto.opentelemetry.proto.common.v1.StringKeyValue.prototype.setValue = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.common.v1.InstrumentationLibrary.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.toObject = function(includeInstance, msg) { - var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, ""), - version: jspb.Message.getFieldWithDefault(msg, 2, "") - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.common.v1.InstrumentationLibrary; - return proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setVersion(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.common.v1.InstrumentationLibrary.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getVersion(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * optional string name = 1; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} returns this - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string version = 2; - * @return {string} - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.getVersion = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.common.v1.InstrumentationLibrary} returns this - */ -proto.opentelemetry.proto.common.v1.InstrumentationLibrary.prototype.setVersion = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -goog.object.extend(exports, proto.opentelemetry.proto.common.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js deleted file mode 100644 index d03e6a365e..0000000000 --- a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/resource/v1/resource_pb.js +++ /dev/null @@ -1,229 +0,0 @@ -// source: opentelemetry/proto/resource/v1/resource.proto -/** - * @fileoverview - * @enhanceable - * @suppress {messageConventions} JS Compiler reports an error if a variable or - * field starts with 'MSG_' and isn't a translatable message. - * @public - */ -// GENERATED CODE -- DO NOT EDIT! - -var jspb = require('google-protobuf'); -var goog = jspb; -var global = Function('return this')(); - -var opentelemetry_proto_common_v1_common_pb = require('../../../../opentelemetry/proto/common/v1/common_pb.js'); -goog.object.extend(proto, opentelemetry_proto_common_v1_common_pb); -goog.exportSymbol('proto.opentelemetry.proto.resource.v1.Resource', null, global); -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.resource.v1.Resource = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.resource.v1.Resource.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.resource.v1.Resource, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.resource.v1.Resource.displayName = 'proto.opentelemetry.proto.resource.v1.Resource'; -} - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.resource.v1.Resource.repeatedFields_ = [1]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.resource.v1.Resource.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.resource.v1.Resource} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.resource.v1.Resource.toObject = function(includeInstance, msg) { - var f, obj = { - attributesList: jspb.Message.toObjectList(msg.getAttributesList(), - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), - droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 2, 0) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.resource.v1.Resource} - */ -proto.opentelemetry.proto.resource.v1.Resource.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.resource.v1.Resource; - return proto.opentelemetry.proto.resource.v1.Resource.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.resource.v1.Resource} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.resource.v1.Resource} - */ -proto.opentelemetry.proto.resource.v1.Resource.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; - reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); - msg.addAttributes(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedAttributesCount(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.resource.v1.Resource.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.resource.v1.Resource} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.resource.v1.Resource.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getAttributesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 1, - f, - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter - ); - } - f = message.getDroppedAttributesCount(); - if (f !== 0) { - writer.writeUint32( - 2, - f - ); - } -}; - - -/** - * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 1; - * @return {!Array} - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.getAttributesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 1)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this -*/ -proto.opentelemetry.proto.resource.v1.Resource.prototype.setAttributesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.addAttributes = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.clearAttributesList = function() { - return this.setAttributesList([]); -}; - - -/** - * optional uint32 dropped_attributes_count = 2; - * @return {number} - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.getDroppedAttributesCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.resource.v1.Resource} returns this - */ -proto.opentelemetry.proto.resource.v1.Resource.prototype.setDroppedAttributesCount = function(value) { - return jspb.Message.setProto3IntField(this, 2, value); -}; - - -goog.object.extend(exports, proto.opentelemetry.proto.resource.v1); diff --git a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js b/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js deleted file mode 100644 index 42a4524c1f..0000000000 --- a/packages/opentelemetry-exporter-collector/generated/opentelemetry/proto/trace/v1/trace_pb.js +++ /dev/null @@ -1,2067 +0,0 @@ -// source: opentelemetry/proto/trace/v1/trace.proto -/** - * @fileoverview - * @enhanceable - * @suppress {messageConventions} JS Compiler reports an error if a variable or - * field starts with 'MSG_' and isn't a translatable message. - * @public - */ -// GENERATED CODE -- DO NOT EDIT! - -var jspb = require('google-protobuf'); -var goog = jspb; -var global = Function('return this')(); - -var opentelemetry_proto_common_v1_common_pb = require('../../../../opentelemetry/proto/common/v1/common_pb.js'); -goog.object.extend(proto, opentelemetry_proto_common_v1_common_pb); -var opentelemetry_proto_resource_v1_resource_pb = require('../../../../opentelemetry/proto/resource/v1/resource_pb.js'); -goog.object.extend(proto, opentelemetry_proto_resource_v1_resource_pb); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.ResourceSpans', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.Event', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.Link', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Span.SpanKind', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Status', null, global); -goog.exportSymbol('proto.opentelemetry.proto.trace.v1.Status.StatusCode', null, global); -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.ResourceSpans.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.ResourceSpans, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.ResourceSpans.displayName = 'proto.opentelemetry.proto.trace.v1.ResourceSpans'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.displayName = 'proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.Span = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.Span, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.Span.displayName = 'proto.opentelemetry.proto.trace.v1.Span'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.Span.Event = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.Event.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.Span.Event, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.Span.Event.displayName = 'proto.opentelemetry.proto.trace.v1.Span.Event'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.Span.Link = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.opentelemetry.proto.trace.v1.Span.Link.repeatedFields_, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.Span.Link, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.Span.Link.displayName = 'proto.opentelemetry.proto.trace.v1.Span.Link'; -} -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.opentelemetry.proto.trace.v1.Status = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.opentelemetry.proto.trace.v1.Status, jspb.Message); -if (goog.DEBUG && !COMPILED) { - /** - * @public - * @override - */ - proto.opentelemetry.proto.trace.v1.Status.displayName = 'proto.opentelemetry.proto.trace.v1.Status'; -} - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.repeatedFields_ = [2]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.ResourceSpans.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.toObject = function(includeInstance, msg) { - var f, obj = { - resource: (f = msg.getResource()) && opentelemetry_proto_resource_v1_resource_pb.Resource.toObject(includeInstance, f), - instrumentationLibrarySpansList: jspb.Message.toObjectList(msg.getInstrumentationLibrarySpansList(), - proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject, includeInstance) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.ResourceSpans; - return proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = new opentelemetry_proto_resource_v1_resource_pb.Resource; - reader.readMessage(value,opentelemetry_proto_resource_v1_resource_pb.Resource.deserializeBinaryFromReader); - msg.setResource(value); - break; - case 2: - var value = new proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans; - reader.readMessage(value,proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader); - msg.addInstrumentationLibrarySpans(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.ResourceSpans.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.ResourceSpans} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getResource(); - if (f != null) { - writer.writeMessage( - 1, - f, - opentelemetry_proto_resource_v1_resource_pb.Resource.serializeBinaryToWriter - ); - } - f = message.getInstrumentationLibrarySpansList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 2, - f, - proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter - ); - } -}; - - -/** - * optional opentelemetry.proto.resource.v1.Resource resource = 1; - * @return {?proto.opentelemetry.proto.resource.v1.Resource} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.getResource = function() { - return /** @type{?proto.opentelemetry.proto.resource.v1.Resource} */ ( - jspb.Message.getWrapperField(this, opentelemetry_proto_resource_v1_resource_pb.Resource, 1)); -}; - - -/** - * @param {?proto.opentelemetry.proto.resource.v1.Resource|undefined} value - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this -*/ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.setResource = function(value) { - return jspb.Message.setWrapperField(this, 1, value); -}; - - -/** - * Clears the message field making it undefined. - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.clearResource = function() { - return this.setResource(undefined); -}; - - -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.hasResource = function() { - return jspb.Message.getField(this, 1) != null; -}; - - -/** - * repeated InstrumentationLibrarySpans instrumentation_library_spans = 2; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.getInstrumentationLibrarySpansList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, 2)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this -*/ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.setInstrumentationLibrarySpansList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.addInstrumentationLibrarySpans = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.ResourceSpans} returns this - */ -proto.opentelemetry.proto.trace.v1.ResourceSpans.prototype.clearInstrumentationLibrarySpansList = function() { - return this.setInstrumentationLibrarySpansList([]); -}; - - - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.repeatedFields_ = [2]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.toObject = function(includeInstance, msg) { - var f, obj = { - instrumentationLibrary: (f = msg.getInstrumentationLibrary()) && opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.toObject(includeInstance, f), - spansList: jspb.Message.toObjectList(msg.getSpansList(), - proto.opentelemetry.proto.trace.v1.Span.toObject, includeInstance) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans; - return proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = new opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary; - reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.deserializeBinaryFromReader); - msg.setInstrumentationLibrary(value); - break; - case 2: - var value = new proto.opentelemetry.proto.trace.v1.Span; - reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader); - msg.addSpans(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getInstrumentationLibrary(); - if (f != null) { - writer.writeMessage( - 1, - f, - opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary.serializeBinaryToWriter - ); - } - f = message.getSpansList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 2, - f, - proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter - ); - } -}; - - -/** - * optional opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1; - * @return {?proto.opentelemetry.proto.common.v1.InstrumentationLibrary} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.getInstrumentationLibrary = function() { - return /** @type{?proto.opentelemetry.proto.common.v1.InstrumentationLibrary} */ ( - jspb.Message.getWrapperField(this, opentelemetry_proto_common_v1_common_pb.InstrumentationLibrary, 1)); -}; - - -/** - * @param {?proto.opentelemetry.proto.common.v1.InstrumentationLibrary|undefined} value - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this -*/ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.setInstrumentationLibrary = function(value) { - return jspb.Message.setWrapperField(this, 1, value); -}; - - -/** - * Clears the message field making it undefined. - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.clearInstrumentationLibrary = function() { - return this.setInstrumentationLibrary(undefined); -}; - - -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.hasInstrumentationLibrary = function() { - return jspb.Message.getField(this, 1) != null; -}; - - -/** - * repeated Span spans = 2; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.getSpansList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span, 2)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this -*/ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.setSpansList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.Span=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.trace.v1.Span} - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.addSpans = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.opentelemetry.proto.trace.v1.Span, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans} returns this - */ -proto.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.prototype.clearSpansList = function() { - return this.setSpansList([]); -}; - - - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.trace.v1.Span.repeatedFields_ = [9,11,13]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.Span.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.Span} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.toObject = function(includeInstance, msg) { - var f, obj = { - traceId: msg.getTraceId_asB64(), - spanId: msg.getSpanId_asB64(), - traceState: jspb.Message.getFieldWithDefault(msg, 3, ""), - parentSpanId: msg.getParentSpanId_asB64(), - name: jspb.Message.getFieldWithDefault(msg, 5, ""), - kind: jspb.Message.getFieldWithDefault(msg, 6, 0), - startTimeUnixNano: jspb.Message.getFieldWithDefault(msg, 7, 0), - endTimeUnixNano: jspb.Message.getFieldWithDefault(msg, 8, 0), - attributesList: jspb.Message.toObjectList(msg.getAttributesList(), - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), - droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 10, 0), - eventsList: jspb.Message.toObjectList(msg.getEventsList(), - proto.opentelemetry.proto.trace.v1.Span.Event.toObject, includeInstance), - droppedEventsCount: jspb.Message.getFieldWithDefault(msg, 12, 0), - linksList: jspb.Message.toObjectList(msg.getLinksList(), - proto.opentelemetry.proto.trace.v1.Span.Link.toObject, includeInstance), - droppedLinksCount: jspb.Message.getFieldWithDefault(msg, 14, 0), - status: (f = msg.getStatus()) && proto.opentelemetry.proto.trace.v1.Status.toObject(includeInstance, f) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.Span} - */ -proto.opentelemetry.proto.trace.v1.Span.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.Span; - return proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.Span} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.Span} - */ -proto.opentelemetry.proto.trace.v1.Span.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTraceId(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setSpanId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setTraceState(value); - break; - case 4: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setParentSpanId(value); - break; - case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 6: - var value = /** @type {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} */ (reader.readEnum()); - msg.setKind(value); - break; - case 7: - var value = /** @type {number} */ (reader.readFixed64()); - msg.setStartTimeUnixNano(value); - break; - case 8: - var value = /** @type {number} */ (reader.readFixed64()); - msg.setEndTimeUnixNano(value); - break; - case 9: - var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; - reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); - msg.addAttributes(value); - break; - case 10: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedAttributesCount(value); - break; - case 11: - var value = new proto.opentelemetry.proto.trace.v1.Span.Event; - reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader); - msg.addEvents(value); - break; - case 12: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedEventsCount(value); - break; - case 13: - var value = new proto.opentelemetry.proto.trace.v1.Span.Link; - reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader); - msg.addLinks(value); - break; - case 14: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedLinksCount(value); - break; - case 15: - var value = new proto.opentelemetry.proto.trace.v1.Status; - reader.readMessage(value,proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader); - msg.setStatus(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.Span} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getTraceId_asU8(); - if (f.length > 0) { - writer.writeBytes( - 1, - f - ); - } - f = message.getSpanId_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getTraceState(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getParentSpanId_asU8(); - if (f.length > 0) { - writer.writeBytes( - 4, - f - ); - } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 5, - f - ); - } - f = message.getKind(); - if (f !== 0.0) { - writer.writeEnum( - 6, - f - ); - } - f = message.getStartTimeUnixNano(); - if (f !== 0) { - writer.writeFixed64( - 7, - f - ); - } - f = message.getEndTimeUnixNano(); - if (f !== 0) { - writer.writeFixed64( - 8, - f - ); - } - f = message.getAttributesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 9, - f, - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter - ); - } - f = message.getDroppedAttributesCount(); - if (f !== 0) { - writer.writeUint32( - 10, - f - ); - } - f = message.getEventsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 11, - f, - proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter - ); - } - f = message.getDroppedEventsCount(); - if (f !== 0) { - writer.writeUint32( - 12, - f - ); - } - f = message.getLinksList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 13, - f, - proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter - ); - } - f = message.getDroppedLinksCount(); - if (f !== 0) { - writer.writeUint32( - 14, - f - ); - } - f = message.getStatus(); - if (f != null) { - writer.writeMessage( - 15, - f, - proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter - ); - } -}; - - -/** - * @enum {number} - */ -proto.opentelemetry.proto.trace.v1.Span.SpanKind = { - SPAN_KIND_UNSPECIFIED: 0, - INTERNAL: 1, - SERVER: 2, - CLIENT: 3, - PRODUCER: 4, - CONSUMER: 5 -}; - - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.trace.v1.Span.Event.repeatedFields_ = [3]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.Span.Event.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.Event.toObject = function(includeInstance, msg) { - var f, obj = { - timeUnixNano: jspb.Message.getFieldWithDefault(msg, 1, 0), - name: jspb.Message.getFieldWithDefault(msg, 2, ""), - attributesList: jspb.Message.toObjectList(msg.getAttributesList(), - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), - droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 4, 0) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.Span.Event; - return proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readFixed64()); - msg.setTimeUnixNano(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 3: - var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; - reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); - msg.addAttributes(value); - break; - case 4: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedAttributesCount(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.Span.Event} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.Event.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getTimeUnixNano(); - if (f !== 0) { - writer.writeFixed64( - 1, - f - ); - } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getAttributesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 3, - f, - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter - ); - } - f = message.getDroppedAttributesCount(); - if (f !== 0) { - writer.writeUint32( - 4, - f - ); - } -}; - - -/** - * optional fixed64 time_unix_nano = 1; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getTimeUnixNano = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setTimeUnixNano = function(value) { - return jspb.Message.setProto3IntField(this, 1, value); -}; - - -/** - * optional string name = 2; - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -/** - * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 3; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getAttributesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 3)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setAttributesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 3, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.addAttributes = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.clearAttributesList = function() { - return this.setAttributesList([]); -}; - - -/** - * optional uint32 dropped_attributes_count = 4; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.getDroppedAttributesCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Event.prototype.setDroppedAttributesCount = function(value) { - return jspb.Message.setProto3IntField(this, 4, value); -}; - - - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.opentelemetry.proto.trace.v1.Span.Link.repeatedFields_ = [4]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.Span.Link.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.Link.toObject = function(includeInstance, msg) { - var f, obj = { - traceId: msg.getTraceId_asB64(), - spanId: msg.getSpanId_asB64(), - traceState: jspb.Message.getFieldWithDefault(msg, 3, ""), - attributesList: jspb.Message.toObjectList(msg.getAttributesList(), - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.toObject, includeInstance), - droppedAttributesCount: jspb.Message.getFieldWithDefault(msg, 5, 0) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.Span.Link; - return proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTraceId(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setSpanId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setTraceState(value); - break; - case 4: - var value = new opentelemetry_proto_common_v1_common_pb.AttributeKeyValue; - reader.readMessage(value,opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.deserializeBinaryFromReader); - msg.addAttributes(value); - break; - case 5: - var value = /** @type {number} */ (reader.readUint32()); - msg.setDroppedAttributesCount(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.Span.Link} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Span.Link.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getTraceId_asU8(); - if (f.length > 0) { - writer.writeBytes( - 1, - f - ); - } - f = message.getSpanId_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getTraceState(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getAttributesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 4, - f, - opentelemetry_proto_common_v1_common_pb.AttributeKeyValue.serializeBinaryToWriter - ); - } - f = message.getDroppedAttributesCount(); - if (f !== 0) { - writer.writeUint32( - 5, - f - ); - } -}; - - -/** - * optional bytes trace_id = 1; - * @return {!(string|Uint8Array)} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes trace_id = 1; - * This is a type-conversion wrapper around `getTraceId()` - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTraceId())); -}; - - -/** - * optional bytes trace_id = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTraceId()` - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceId_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTraceId())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setTraceId = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); -}; - - -/** - * optional bytes span_id = 2; - * @return {!(string|Uint8Array)} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes span_id = 2; - * This is a type-conversion wrapper around `getSpanId()` - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getSpanId())); -}; - - -/** - * optional bytes span_id = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getSpanId()` - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getSpanId_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getSpanId())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setSpanId = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; - - -/** - * optional string trace_state = 3; - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getTraceState = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setTraceState = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 4; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getAttributesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 4)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setAttributesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 4, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.addAttributes = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 4, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.clearAttributesList = function() { - return this.setAttributesList([]); -}; - - -/** - * optional uint32 dropped_attributes_count = 5; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.getDroppedAttributesCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.Link.prototype.setDroppedAttributesCount = function(value) { - return jspb.Message.setProto3IntField(this, 5, value); -}; - - -/** - * optional bytes trace_id = 1; - * @return {!(string|Uint8Array)} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes trace_id = 1; - * This is a type-conversion wrapper around `getTraceId()` - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTraceId())); -}; - - -/** - * optional bytes trace_id = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTraceId()` - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceId_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTraceId())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setTraceId = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); -}; - - -/** - * optional bytes span_id = 2; - * @return {!(string|Uint8Array)} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes span_id = 2; - * This is a type-conversion wrapper around `getSpanId()` - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getSpanId())); -}; - - -/** - * optional bytes span_id = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getSpanId()` - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getSpanId_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getSpanId())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setSpanId = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; - - -/** - * optional string trace_state = 3; - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getTraceState = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setTraceState = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional bytes parent_span_id = 4; - * @return {!(string|Uint8Array)} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * optional bytes parent_span_id = 4; - * This is a type-conversion wrapper around `getParentSpanId()` - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getParentSpanId())); -}; - - -/** - * optional bytes parent_span_id = 4; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getParentSpanId()` - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getParentSpanId_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getParentSpanId())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setParentSpanId = function(value) { - return jspb.Message.setProto3BytesField(this, 4, value); -}; - - -/** - * optional string name = 5; - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); -}; - - -/** - * optional SpanKind kind = 6; - * @return {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getKind = function() { - return /** @type {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.Span.SpanKind} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setKind = function(value) { - return jspb.Message.setProto3EnumField(this, 6, value); -}; - - -/** - * optional fixed64 start_time_unix_nano = 7; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getStartTimeUnixNano = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setStartTimeUnixNano = function(value) { - return jspb.Message.setProto3IntField(this, 7, value); -}; - - -/** - * optional fixed64 end_time_unix_nano = 8; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getEndTimeUnixNano = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setEndTimeUnixNano = function(value) { - return jspb.Message.setProto3IntField(this, 8, value); -}; - - -/** - * repeated opentelemetry.proto.common.v1.AttributeKeyValue attributes = 9; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getAttributesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, opentelemetry_proto_common_v1_common_pb.AttributeKeyValue, 9)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.prototype.setAttributesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 9, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.common.v1.AttributeKeyValue=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.common.v1.AttributeKeyValue} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.addAttributes = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 9, opt_value, proto.opentelemetry.proto.common.v1.AttributeKeyValue, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.clearAttributesList = function() { - return this.setAttributesList([]); -}; - - -/** - * optional uint32 dropped_attributes_count = 10; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedAttributesCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 10, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedAttributesCount = function(value) { - return jspb.Message.setProto3IntField(this, 10, value); -}; - - -/** - * repeated Event events = 11; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getEventsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span.Event, 11)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.prototype.setEventsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 11, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.Span.Event=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.trace.v1.Span.Event} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.addEvents = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 11, opt_value, proto.opentelemetry.proto.trace.v1.Span.Event, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.clearEventsList = function() { - return this.setEventsList([]); -}; - - -/** - * optional uint32 dropped_events_count = 12; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedEventsCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 12, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedEventsCount = function(value) { - return jspb.Message.setProto3IntField(this, 12, value); -}; - - -/** - * repeated Link links = 13; - * @return {!Array} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getLinksList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.opentelemetry.proto.trace.v1.Span.Link, 13)); -}; - - -/** - * @param {!Array} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.prototype.setLinksList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 13, value); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.Span.Link=} opt_value - * @param {number=} opt_index - * @return {!proto.opentelemetry.proto.trace.v1.Span.Link} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.addLinks = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 13, opt_value, proto.opentelemetry.proto.trace.v1.Span.Link, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.clearLinksList = function() { - return this.setLinksList([]); -}; - - -/** - * optional uint32 dropped_links_count = 14; - * @return {number} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getDroppedLinksCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 14, 0)); -}; - - -/** - * @param {number} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.setDroppedLinksCount = function(value) { - return jspb.Message.setProto3IntField(this, 14, value); -}; - - -/** - * optional Status status = 15; - * @return {?proto.opentelemetry.proto.trace.v1.Status} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.getStatus = function() { - return /** @type{?proto.opentelemetry.proto.trace.v1.Status} */ ( - jspb.Message.getWrapperField(this, proto.opentelemetry.proto.trace.v1.Status, 15)); -}; - - -/** - * @param {?proto.opentelemetry.proto.trace.v1.Status|undefined} value - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this -*/ -proto.opentelemetry.proto.trace.v1.Span.prototype.setStatus = function(value) { - return jspb.Message.setWrapperField(this, 15, value); -}; - - -/** - * Clears the message field making it undefined. - * @return {!proto.opentelemetry.proto.trace.v1.Span} returns this - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.clearStatus = function() { - return this.setStatus(undefined); -}; - - -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.opentelemetry.proto.trace.v1.Span.prototype.hasStatus = function() { - return jspb.Message.getField(this, 15) != null; -}; - - - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.toObject = function(opt_includeInstance) { - return proto.opentelemetry.proto.trace.v1.Status.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.opentelemetry.proto.trace.v1.Status} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Status.toObject = function(includeInstance, msg) { - var f, obj = { - code: jspb.Message.getFieldWithDefault(msg, 1, 0), - message: jspb.Message.getFieldWithDefault(msg, 2, "") - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.opentelemetry.proto.trace.v1.Status} - */ -proto.opentelemetry.proto.trace.v1.Status.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.opentelemetry.proto.trace.v1.Status; - return proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.opentelemetry.proto.trace.v1.Status} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.opentelemetry.proto.trace.v1.Status} - */ -proto.opentelemetry.proto.trace.v1.Status.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} */ (reader.readEnum()); - msg.setCode(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setMessage(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.opentelemetry.proto.trace.v1.Status} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.opentelemetry.proto.trace.v1.Status.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getCode(); - if (f !== 0.0) { - writer.writeEnum( - 1, - f - ); - } - f = message.getMessage(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * @enum {number} - */ -proto.opentelemetry.proto.trace.v1.Status.StatusCode = { - OK: 0, - CANCELLED: 1, - UNKNOWNERROR: 2, - INVALIDARGUMENT: 3, - DEADLINEEXCEEDED: 4, - NOTFOUND: 5, - ALREADYEXISTS: 6, - PERMISSIONDENIED: 7, - RESOURCEEXHAUSTED: 8, - FAILEDPRECONDITION: 9, - ABORTED: 10, - OUTOFRANGE: 11, - UNIMPLEMENTED: 12, - INTERNALERROR: 13, - UNAVAILABLE: 14, - DATALOSS: 15, - UNAUTHENTICATED: 16 -}; - -/** - * optional StatusCode code = 1; - * @return {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.getCode = function() { - return /** @type {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); -}; - - -/** - * @param {!proto.opentelemetry.proto.trace.v1.Status.StatusCode} value - * @return {!proto.opentelemetry.proto.trace.v1.Status} returns this - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.setCode = function(value) { - return jspb.Message.setProto3EnumField(this, 1, value); -}; - - -/** - * optional string message = 2; - * @return {string} - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.opentelemetry.proto.trace.v1.Status} returns this - */ -proto.opentelemetry.proto.trace.v1.Status.prototype.setMessage = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -goog.object.extend(exports, proto.opentelemetry.proto.trace.v1); diff --git a/packages/opentelemetry-exporter-collector/package.json b/packages/opentelemetry-exporter-collector/package.json index 673ef3dba2..f1401ebbad 100644 --- a/packages/opentelemetry-exporter-collector/package.json +++ b/packages/opentelemetry-exporter-collector/package.json @@ -16,18 +16,16 @@ "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../", "precompile": "tsc --version", "compile": "npm run version:update && tsc -p .", - "generate:http-proto": "rimraf ./generated/* && ./gen.sh", - "postcompile": "npm run submodule && npm run protos:copy && npm run generated:copy", + "postcompile": "npm run submodule && npm run protos:copy", "prepare": "npm run compile", "protos:copy": "cpx src/platform/node/protos/opentelemetry/**/*.* build/src/platform/node/protos/opentelemetry", - "generated:copy": "cpx generated/**/*.* build/generated", "submodule": "git submodule sync --recursive && git submodule update --init --recursive", "tdd": "npm run test -- --watch-extensions ts --watch", "tdd:browser": "karma start", "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts' --exclude 'test/browser/**/*.ts'", "test:browser": "nyc karma start --single-run", "version:update": "node ../../scripts/version-update.js", - "watch": "npm run protos:copy && npm run generated:copy && tsc -w" + "watch": "npm run protos:copy && tsc -w" }, "keywords": [ "opentelemetry", @@ -93,7 +91,7 @@ "@opentelemetry/resources": "^0.9.0", "@opentelemetry/metrics": "^0.9.0", "@opentelemetry/tracing": "^0.9.0", - "google-protobuf": "^3.11.4", + "protobufjs": "^6.9.0", "grpc": "^1.24.2" } } diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/README.md b/packages/opentelemetry-exporter-collector/src/platform/node/README.md index 5827349a43..fe7705795e 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/README.md +++ b/packages/opentelemetry-exporter-collector/src/platform/node/README.md @@ -45,12 +45,4 @@ the latest sha when this guide was written is `b54688569186e0b862bf7462a983ccf2c 9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one -10. After upgrading protos you should regenerate proto files for js. -**You need to have protocol buffers installed to be able to generate them**. - -```shell script -npm run generate:http-proto -``` - -After this command it should generate a new js files in folder "generated". Make sure it compiles correctly. diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts deleted file mode 100644 index 7d96424658..0000000000 --- a/packages/opentelemetry-exporter-collector/src/platform/node/transformSpansProto.ts +++ /dev/null @@ -1,293 +0,0 @@ -/* - * 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. - */ - -/* eslint @typescript-eslint/no-var-requires: 0 */ - -// import * as pgTrace from '../../../generated/opentelemetry/proto/trace/v1/trace'; -// import * as pgResource from '../../../generated/opentelemetry/proto/resource/v1/resource'; -// import * as pgCommon from '../../../generated/opentelemetry/proto/common/v1/common'; -// import * as pgCollector from '../../../generated/opentelemetry/proto/collector/trace/v1/trace_service'; -const pgTrace = require('../../../generated/opentelemetry/proto/trace/v1/trace_pb'); -const pgResource = require('../../../generated/opentelemetry/proto/resource/v1/resource_pb'); -const pgCommon = require('../../../generated/opentelemetry/proto/common/v1/common_pb'); -const pgCollector = require('../../../generated/opentelemetry/proto/collector/trace/v1/trace_service_pb'); - -import { - Attributes, - Link, - SpanKind, - Status, - TimedEvent, - TraceState, -} from '@opentelemetry/api'; -import * as core from '@opentelemetry/core'; -import { Resource } from '@opentelemetry/resources'; -import { ReadableSpan } from '@opentelemetry/tracing'; -import { CollectorTraceExporterBase } from '../../CollectorTraceExporterBase'; -import { groupSpansByResourceAndLibrary } from '../../transform'; -import { COLLECTOR_SPAN_KIND_MAPPING, opentelemetryProto } from '../../types'; -import ValueType = opentelemetryProto.common.v1.ValueType; -import { InstrumentationLibrary } from '@opentelemetry/core'; -import { CollectorExporterConfigNode } from './types'; - -/** - * Converts attributes - * @param attributes - */ -export function toCollectorAttributes(attributes: Attributes) { - //: pgCommon.opentelemetry.proto.common.v1.AttributeKeyValue[] { - return Object.keys(attributes).map(key => { - return toCollectorAttributeKeyValue(key, attributes[key]); - }); -} - -/** - * Converts key and value to AttributeKeyValue - * @param value event value - */ -export function toCollectorAttributeKeyValue(key: string, value: unknown) { - //: pgCommon.opentelemetry.proto.common.v1.AttributeKeyValue { - const attributeKeyValue = new pgCommon.AttributeKeyValue(); - attributeKeyValue.setKey(key); - - if (typeof value === 'string') { - attributeKeyValue.setStringValue(value); - attributeKeyValue.setType(ValueType.STRING); - } else if (typeof value === 'boolean') { - attributeKeyValue.setBoolValue(value); - attributeKeyValue.setType(ValueType.BOOL); - } else if (typeof value === 'number') { - // all numbers will be treated as double - attributeKeyValue.setDoubleValue(value); - attributeKeyValue.setType(ValueType.DOUBLE); - } - return attributeKeyValue; -} - -/** - * - * Converts events - * @param events array of events - */ -export function toCollectorEvents(timedEvents: TimedEvent[]) { - //: pgTrace.opentelemetry.proto.trace.v1.Span.Event[] { - return timedEvents.map(timedEvent => { - const timeUnixNano = core.hrTimeToNanoseconds(timedEvent.time); - const name = timedEvent.name; - const attributes = toCollectorAttributes(timedEvent.attributes || {}); - const droppedAttributesCount = 0; - const protoEvent = new pgTrace.Span.Event(); - protoEvent.setTimeUnixNano(timeUnixNano); - protoEvent.setName(name); - protoEvent.setAttributesList(attributes); - protoEvent.setDroppedAttributesCount(droppedAttributesCount); - - return protoEvent; - }); -} - -/** - * Converts links - * @param span - */ -export function toCollectorLinks(span: ReadableSpan) { - //: pgTrace.opentelemetry.proto.trace.v1.Span.Link[] { - return span.links.map((link: Link) => { - const protoLink = new pgTrace.Span.Link(); - protoLink.setTraceId(hexToBuffer(link.context.traceId)); - protoLink.setSpanId(hexToBuffer(link.context.spanId)); - protoLink.setAttributesList(toCollectorAttributes(link.attributes || {})); - protoLink.setDroppedAttributesCount(0); - return protoLink; - }); -} - -export function toCollectorStatus(status: Status) { - //: pgTrace.opentelemetry.proto.trace.v1.Status { - const protoStatus = new pgTrace.Status(); - protoStatus.setCode(status.code); - protoStatus.setMessage(status.message); - return protoStatus; -} - -/** - * Converts span - * @param span - */ -export function toCollectorSpan(span: ReadableSpan) { - //: pgTrace.opentelemetry.proto.trace.v1.Span { - const protoSpan = new pgTrace.Span(); - - protoSpan.setTraceId(hexToBuffer(span.spanContext.traceId)); - protoSpan.setSpanId(hexToBuffer(span.spanContext.spanId)); - if (span.parentSpanId) { - protoSpan.setParentSpanId(hexToBuffer(span.parentSpanId)); - } - protoSpan.setTraceState(toCollectorTraceState(span.spanContext.traceState)); - protoSpan.setName(span.name); - protoSpan.setKind(toCollectorKind(span.kind)); - protoSpan.setStartTimeUnixNano(core.hrTimeToNanoseconds(span.startTime)); - protoSpan.setEndTimeUnixNano(core.hrTimeToNanoseconds(span.endTime)); - - protoSpan.setAttributesList(toCollectorAttributes(span.attributes)); - protoSpan.setDroppedAttributesCount(0); - - protoSpan.setEventsList(toCollectorEvents(span.events)); - protoSpan.setDroppedEventsCount(0); - - protoSpan.setStatus(toCollectorStatus(span.status)); - - protoSpan.setLinksList(toCollectorLinks(span)); - protoSpan.setDroppedLinksCount(0); - - return protoSpan; -} - -/** - * Converts resource - * @param resource - * @param additionalAttributes - */ -export function toCollectorResource( - resource?: Resource, - additionalAttributes: { [key: string]: unknown } = {} -) { - //: pgResource.opentelemetry.proto.resource.v1.Resource { - // pgResource.opentelemetry.proto.resource.v1.Resource - // pgTrace.opentelemetry.proto. trace.v1.ResourceSpans - const attr = Object.assign( - {}, - additionalAttributes, - resource ? resource.labels : {} - ); - const resourceProto = new pgResource.Resource(); - const attributes = toCollectorAttributes(attr); - resourceProto.setAttributesList(attributes); - resourceProto.setDroppedAttributesCount(0); - return resourceProto; -} - -/** - * Converts span kind - * @param kind - */ -export function toCollectorKind(kind: SpanKind) { - //: pgTrace.opentelemetry.proto.trace.v1.Span.SpanKind { - const collectorKind = COLLECTOR_SPAN_KIND_MAPPING[kind]; - return typeof collectorKind === 'number' - ? collectorKind - : opentelemetryProto.trace.v1.Span.SpanKind.SPAN_KIND_UNSPECIFIED; -} - -/** - * Converts traceState - * @param traceState - */ -export function toCollectorTraceState(traceState?: TraceState) { - //: string | undefined { - if (!traceState) { - return undefined; - } - return traceState.serialize(); -} - -/** - * Prepares trace service request to be sent to collector - * @param spans spans - * @param collectorTraceExporter - * @param [name] Instrumentation Library Name - */ -export function toCollectorExportTraceServiceRequest< - T extends CollectorExporterConfigNode ->( - spans: ReadableSpan[], - collectorTraceExporter: CollectorTraceExporterBase -) { - //: pgCollector.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest { - const groupedSpans: Map< - Resource, - Map - > = groupSpansByResourceAndLibrary(spans); - - const additionalAttributes = Object.assign( - {}, - collectorTraceExporter.attributes || {}, - { - 'service.name': collectorTraceExporter.serviceName, - } - ); - - const exportTraceServiceRequest = new pgCollector.ExportTraceServiceRequest(); - const resourceSpans = toCollectorResourceSpans( - groupedSpans, - additionalAttributes - ); - exportTraceServiceRequest.setResourceSpansList(resourceSpans); - - return exportTraceServiceRequest; -} - -function toCollectorInstrumentationLibrarySpans( - instrumentationLibrary: InstrumentationLibrary, - spans: ReadableSpan[] -) { - //: pgTrace.opentelemetry.proto.trace.v1.InstrumentationLibrarySpans { - const instrumentationLibrarySpans = new pgTrace.InstrumentationLibrarySpans(); - - const protoSpans = spans.map(toCollectorSpan); - instrumentationLibrarySpans.setSpansList(protoSpans); - - const protoInstrumentationLibrary = new pgCommon.InstrumentationLibrary(); - protoInstrumentationLibrary.setName(instrumentationLibrary.name); - protoInstrumentationLibrary.setVersion(instrumentationLibrary.version); - instrumentationLibrarySpans.setInstrumentationLibrary( - protoInstrumentationLibrary - ); - - return instrumentationLibrarySpans; -} - -function toCollectorResourceSpans( - groupedSpans: Map>, - baseAttributes: Attributes -) { - //: pgTrace.opentelemetry.proto.trace.v1.ResourceSpans[] { - return Array.from(groupedSpans, ([resource, libSpans]) => { - const resourceSpans = new pgTrace.ResourceSpans(); - const res = toCollectorResource(resource, baseAttributes); - resourceSpans.setResource(res); - const instrumentationLibrarySpans = Array.from( - libSpans, - ([instrumentationLibrary, spans]) => - toCollectorInstrumentationLibrarySpans(instrumentationLibrary, spans) - ); - resourceSpans.setInstrumentationLibrarySpansList( - instrumentationLibrarySpans - ); - return resourceSpans; - }); -} - -function hexToBuffer(hexStr: string): Uint8Array { - const hexStrLen = hexStr.length; - let hexAsciiCharsStr = ''; - for (let i = 0; i < hexStrLen; i += 2) { - const hexPair = hexStr.substring(i, i + 2); - const hexVal = parseInt(hexPair, 16); - hexAsciiCharsStr += String.fromCharCode(hexVal); - } - return Buffer.from(hexAsciiCharsStr, 'ascii'); -} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts index e4777cbaba..ae7ffa2b60 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts @@ -15,20 +15,42 @@ */ import { ReadableSpan } from '@opentelemetry/tracing'; +import * as path from 'path'; +import { Type } from 'protobufjs'; +import * as protobufjs from 'protobufjs'; +import { toCollectorExportTraceServiceRequest } from '../../transform'; import * as collectorTypes from '../../types'; import { CollectorTraceExporter } from './CollectorTraceExporter'; -import { toCollectorExportTraceServiceRequest } from './transformSpansProto'; import { CollectorExporterConfigNode } from './types'; import { sendDataUsingHttp } from './util'; export const DEFAULT_COLLECTOR_URL_JSON_PROTO = 'http://localhost:55680/v1/trace'; +let ExportTraceServiceRequestProto: Type | undefined; + +export function getExportTraceServiceRequestProto(): Type | undefined { + return ExportTraceServiceRequestProto; +} + export function onInitWithJsonProto( _collector: CollectorTraceExporter, _config: CollectorExporterConfigNode ): void { - // nothing to be done for json proto yet + const dir = path.resolve(__dirname, 'protos'); + const root = new protobufjs.Root(); + root.resolvePath = function (origin, target) { + return `${dir}/${target}`; + }; + const proto = root.loadSync([ + 'opentelemetry/proto/common/v1/common.proto', + 'opentelemetry/proto/resource/v1/resource.proto', + 'opentelemetry/proto/trace/v1/trace.proto', + 'opentelemetry/proto/collector/trace/v1/trace_service.proto', + ]); + ExportTraceServiceRequestProto = proto?.lookupType( + 'ExportTraceServiceRequest' + ); } /** @@ -49,13 +71,20 @@ export function sendSpansUsingJsonProto( collector ); - const body = exportTraceServiceRequest.serializeBinary(); - - return sendDataUsingHttp( - collector, - Buffer.from(body), - 'application/x-protobuf', - onSuccess, - onError + const message = ExportTraceServiceRequestProto?.create( + exportTraceServiceRequest ); + + if (message) { + const body = ExportTraceServiceRequestProto?.encode(message).finish(); + if (body) { + sendDataUsingHttp( + collector, + Buffer.from(body), + 'application/x-protobuf', + onSuccess, + onError + ); + } + } } diff --git a/packages/opentelemetry-exporter-collector/test/helper.ts b/packages/opentelemetry-exporter-collector/test/helper.ts index 7607beab93..b726141042 100644 --- a/packages/opentelemetry-exporter-collector/test/helper.ts +++ b/packages/opentelemetry-exporter-collector/test/helper.ts @@ -425,6 +425,57 @@ export function ensureEventsAreCorrect( ); } +export function ensureProtoEventsAreCorrect( + events: opentelemetryProto.trace.v1.Span.Event[] +) { + assert.deepStrictEqual( + events, + [ + { + timeUnixNano: '1574120165429803008', + name: 'fetchStart', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165429803008', + name: 'domainLookupStart', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165429803008', + name: 'domainLookupEnd', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165429803008', + name: 'connectStart', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165429803008', + name: 'connectEnd', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165435513088', + name: 'requestStart', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165436923136', + name: 'responseStart', + droppedAttributesCount: 0, + }, + { + timeUnixNano: '1574120165438688000', + name: 'responseEnd', + droppedAttributesCount: 0, + }, + ], + 'events are incorrect' + ); +} + export function ensureAttributesAreCorrect( attributes: opentelemetryProto.common.v1.AttributeKeyValue[] ) { @@ -441,6 +492,22 @@ export function ensureAttributesAreCorrect( ); } +export function ensureProtoAttributesAreCorrect( + attributes: opentelemetryProto.common.v1.AttributeKeyValue[] +) { + assert.deepStrictEqual( + attributes, + [ + { + key: 'component', + type: 'STRING', + stringValue: 'document-load', + }, + ], + 'attributes are incorrect' + ); +} + export function ensureLinksAreCorrect( attributes: opentelemetryProto.trace.v1.Span.Link[] ) { @@ -464,6 +531,29 @@ export function ensureLinksAreCorrect( ); } +export function ensureProtoLinksAreCorrect( + attributes: opentelemetryProto.trace.v1.Span.Link[] +) { + assert.deepStrictEqual( + attributes, + [ + { + traceId: traceIdBase64, + spanId: parentIdBase64, + attributes: [ + { + key: 'component', + type: 'STRING', + stringValue: 'document-load', + }, + ], + droppedAttributesCount: 0, + }, + ], + 'links are incorrect' + ); +} + export function ensureSpanIsCorrect( span: collectorTypes.opentelemetryProto.trace.v1.Span ) { @@ -509,6 +599,47 @@ export function ensureSpanIsCorrect( assert.deepStrictEqual(span.status, { code: 0 }, 'status is wrong'); } +export function ensureProtoSpanIsCorrect( + span: collectorTypes.opentelemetryProto.trace.v1.Span +) { + if (span.attributes) { + ensureProtoAttributesAreCorrect(span.attributes); + } + if (span.events) { + ensureProtoEventsAreCorrect(span.events); + } + if (span.links) { + ensureProtoLinksAreCorrect(span.links); + } + assert.deepStrictEqual(span.traceId, traceIdBase64, 'traceId is wrong'); + assert.deepStrictEqual(span.spanId, spanIdBase64, 'spanId is wrong'); + assert.deepStrictEqual( + span.parentSpanId, + parentIdBase64, + 'parentIdArr is wrong' + ); + assert.strictEqual(span.name, 'documentFetch', 'name is wrong'); + assert.strictEqual(span.kind, 'INTERNAL', 'kind is wrong'); + assert.strictEqual( + span.startTimeUnixNano, + '1574120165429803008', + 'startTimeUnixNano is wrong' + ); + assert.strictEqual( + span.endTimeUnixNano, + '1574120165438688000', + 'endTimeUnixNano is wrong' + ); + assert.strictEqual( + span.droppedAttributesCount, + 0, + 'droppedAttributesCount is wrong' + ); + assert.strictEqual(span.droppedEventsCount, 0, 'droppedEventsCount is wrong'); + assert.strictEqual(span.droppedLinksCount, 0, 'droppedLinksCount is wrong'); + assert.deepStrictEqual(span.status, { code: 'Ok' }, 'status is wrong'); +} + export function ensureExportedSpanIsCorrect( span: collectorTypes.opentelemetryProto.trace.v1.Span ) { diff --git a/packages/opentelemetry-exporter-collector/test/node/CollectorExporterWithProto.test.ts b/packages/opentelemetry-exporter-collector/test/node/CollectorExporterWithProto.test.ts new file mode 100644 index 0000000000..bf009167cb --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/node/CollectorExporterWithProto.test.ts @@ -0,0 +1,188 @@ +/* + * 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 * as core from '@opentelemetry/core'; +import { ReadableSpan } from '@opentelemetry/tracing'; +import * as http from 'http'; +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { CollectorProtocolNode } from '../../src/enums'; +import { CollectorTraceExporter } from '../../src/platform/node'; +import { CollectorExporterConfigNode } from '../../src/platform/node/types'; +import { getExportTraceServiceRequestProto } from '../../src/platform/node/utilWithJsonProto'; +import * as collectorTypes from '../../src/types'; + +import { + ensureExportTraceServiceRequestIsSet, + ensureProtoSpanIsCorrect, + mockedReadableSpan, +} from '../helper'; + +const fakeRequest = { + end: function () {}, + on: function () {}, + write: function () {}, +}; + +const mockRes = { + statusCode: 200, +}; + +const mockResError = { + statusCode: 400, +}; + +describe('CollectorExporter - node with proto over http', () => { + let collectorExporter: CollectorTraceExporter; + let collectorExporterConfig: CollectorExporterConfigNode; + let spyRequest: sinon.SinonSpy; + let spyWrite: sinon.SinonSpy; + let spans: ReadableSpan[]; + describe('export', () => { + beforeEach(() => { + spyRequest = sinon.stub(http, 'request').returns(fakeRequest as any); + spyWrite = sinon.stub(fakeRequest, 'write'); + collectorExporterConfig = { + headers: { + foo: 'bar', + }, + protocolNode: CollectorProtocolNode.HTTP_PROTO, + hostname: 'foo', + logger: new core.NoopLogger(), + serviceName: 'bar', + attributes: {}, + url: 'http://foo.bar.com', + }; + collectorExporter = new CollectorTraceExporter(collectorExporterConfig); + spans = []; + spans.push(Object.assign({}, mockedReadableSpan)); + }); + afterEach(() => { + spyRequest.restore(); + spyWrite.restore(); + }); + + it('should open the connection', done => { + collectorExporter.export(spans, () => {}); + + setTimeout(() => { + const args = spyRequest.args[0]; + const options = args[0]; + + assert.strictEqual(options.hostname, 'foo.bar.com'); + assert.strictEqual(options.method, 'POST'); + assert.strictEqual(options.path, '/'); + done(); + }); + }); + + it('should set custom headers', done => { + collectorExporter.export(spans, () => {}); + + setTimeout(() => { + const args = spyRequest.args[0]; + const options = args[0]; + assert.strictEqual(options.headers['foo'], 'bar'); + done(); + }); + }); + + it('should successfully send the spans', done => { + collectorExporter.export(spans, () => {}); + + setTimeout(() => { + const writeArgs = spyWrite.args[0]; + const ExportTraceServiceRequestProto = getExportTraceServiceRequestProto(); + const data = ExportTraceServiceRequestProto?.decode(writeArgs[0]); + const json = data?.toJSON() as collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest; + const span1 = + json.resourceSpans[0].instrumentationLibrarySpans[0].spans[0]; + assert.ok(typeof span1 !== 'undefined', "span doesn't exist"); + if (span1) { + ensureProtoSpanIsCorrect(span1); + } + + ensureExportTraceServiceRequestIsSet(json); + + done(); + }); + }); + + it('should log the successful message', done => { + const spyLoggerDebug = sinon.stub(collectorExporter.logger, 'debug'); + const spyLoggerError = sinon.stub(collectorExporter.logger, 'error'); + + const responseSpy = sinon.spy(); + collectorExporter.export(spans, responseSpy); + + setTimeout(() => { + const args = spyRequest.args[0]; + const callback = args[1]; + callback(mockRes); + setTimeout(() => { + const response: any = spyLoggerDebug.args[1][0]; + assert.strictEqual(response, 'statusCode: 200'); + assert.strictEqual(spyLoggerError.args.length, 0); + assert.strictEqual(responseSpy.args[0][0], 0); + done(); + }); + }); + }); + + it('should log the error message', done => { + const spyLoggerError = sinon.stub(collectorExporter.logger, 'error'); + + const responseSpy = sinon.spy(); + collectorExporter.export(spans, responseSpy); + + setTimeout(() => { + const args = spyRequest.args[0]; + const callback = args[1]; + callback(mockResError); + setTimeout(() => { + const response: any = spyLoggerError.args[0][0]; + assert.strictEqual(response, 'statusCode: 400'); + + assert.strictEqual(responseSpy.args[0][0], 1); + done(); + }); + }); + }); + }); + describe('CollectorTraceExporter - node (getDefaultUrl)', () => { + it('should default to localhost', done => { + const collectorExporter = new CollectorTraceExporter({ + protocolNode: CollectorProtocolNode.HTTP_PROTO, + }); + setTimeout(() => { + assert.strictEqual( + collectorExporter['url'], + 'http://localhost:55680/v1/trace' + ); + done(); + }); + }); + + it('should keep the URL if included', done => { + const url = 'http://foo.bar.com'; + const collectorExporter = new CollectorTraceExporter({ url }); + setTimeout(() => { + assert.strictEqual(collectorExporter['url'], url); + done(); + }); + }); + }); +}); diff --git a/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts b/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts deleted file mode 100644 index e89ce0d385..0000000000 --- a/packages/opentelemetry-exporter-collector/test/node/transformSpansProto.test.ts +++ /dev/null @@ -1,383 +0,0 @@ -/* - * 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 { Attributes, TimedEvent } from '@opentelemetry/api'; -import * as assert from 'assert'; -import * as transform from '../../src/platform/node/transformSpansProto'; -import { opentelemetryProto } from '../../src/types'; -import { mockedReadableSpan } from '../helper'; -import { Resource } from '@opentelemetry/resources'; - -describe('transform - spans proto', () => { - describe('toCollectorAttributes', () => { - it('should convert attribute string', () => { - const attributes: Attributes = { - foo: 'bar', - }; - assert.deepStrictEqual( - transform.toCollectorAttributes(attributes)[0].toObject(), - { - key: 'foo', - type: 0, - stringValue: 'bar', - intValue: 0, - doubleValue: 0, - boolValue: false, - } - ); - }); - - it('should convert attribute integer', () => { - const attributes: Attributes = { - foo: 13, - }; - assert.deepStrictEqual( - transform.toCollectorAttributes(attributes)[0].toObject(), - { - key: 'foo', - type: 2, - stringValue: '', - intValue: 0, - doubleValue: 13, - boolValue: false, - } - ); - }); - - it('should convert attribute boolean', () => { - const attributes: Attributes = { - foo: true, - }; - assert.deepStrictEqual( - transform.toCollectorAttributes(attributes)[0].toObject(), - { - key: 'foo', - type: 3, - stringValue: '', - intValue: 0, - doubleValue: 0, - boolValue: true, - } - ); - }); - - it('should convert attribute double', () => { - const attributes: Attributes = { - foo: 1.34, - }; - assert.deepStrictEqual( - transform.toCollectorAttributes(attributes)[0].toObject(), - { - key: 'foo', - type: 2, - stringValue: '', - intValue: 0, - doubleValue: 1.34, - boolValue: false, - } - ); - }); - }); - - describe('toCollectorEvents', () => { - it('should convert events to otc events', () => { - const events: TimedEvent[] = [ - { name: 'foo', time: [123, 123], attributes: { a: 'b' } }, - { - name: 'foo2', - time: [321, 321], - attributes: { c: 'd' }, - }, - ]; - const protoEvents = transform.toCollectorEvents(events); - const event1 = protoEvents[0].toObject(); - const event2 = protoEvents[1].toObject(); - assert.deepStrictEqual(event1, { - timeUnixNano: 123000000123, - name: 'foo', - attributesList: [ - { - key: 'a', - type: 0, - stringValue: 'b', - intValue: 0, - doubleValue: 0, - boolValue: false, - }, - ], - droppedAttributesCount: 0, - }); - assert.deepStrictEqual(event2, { - timeUnixNano: 321000000321, - name: 'foo2', - attributesList: [ - { - key: 'c', - type: 0, - stringValue: 'd', - intValue: 0, - doubleValue: 0, - boolValue: false, - }, - ], - droppedAttributesCount: 0, - }); - }); - }); - - describe('toCollectorSpan', () => { - const span = transform.toCollectorSpan(mockedReadableSpan).toObject(); - it('should convert attributes', () => { - assert.deepStrictEqual(span.attributesList, [ - { - key: 'component', - type: 0, - stringValue: 'document-load', - intValue: 0, - doubleValue: 0, - boolValue: false, - }, - ]); - }); - it('should convert events', () => { - assert.deepStrictEqual(span.eventsList, [ - { - timeUnixNano: 1574120165429803000, - name: 'fetchStart', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165429803000, - name: 'domainLookupStart', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165429803000, - name: 'domainLookupEnd', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165429803000, - name: 'connectStart', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165429803000, - name: 'connectEnd', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165435513000, - name: 'requestStart', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165436923100, - name: 'responseStart', - attributesList: [], - droppedAttributesCount: 0, - }, - { - timeUnixNano: 1574120165438688000, - name: 'responseEnd', - attributesList: [], - droppedAttributesCount: 0, - }, - ]); - }); - it('should convert links', () => { - assert.deepStrictEqual(span.linksList, [ - { - traceId: 'HxAI3I4nDoXECg18OTmyeA==', - spanId: 'eKiRUJiGQ4g=', - traceState: '', - attributesList: [ - { - key: 'component', - type: 0, - stringValue: 'document-load', - intValue: 0, - doubleValue: 0, - boolValue: false, - }, - ], - droppedAttributesCount: 0, - }, - ]); - }); - it('should convert trace id', () => { - assert.deepStrictEqual( - span.traceId, - 'HxAI3I4nDoXECg18OTmyeA==', - 'traceId is wrong' - ); - assert.deepStrictEqual(span.spanId, 'XhByYfZPpT4=', 'spanId is wrong'); - assert.deepStrictEqual( - span.parentSpanId, - 'eKiRUJiGQ4g=', - 'parentIdArr is wrong' - ); - assert.strictEqual(span.name, 'documentFetch', 'name is wrong'); - assert.strictEqual( - span.kind, - opentelemetryProto.trace.v1.Span.SpanKind.INTERNAL, - 'kind is wrong' - ); - assert.strictEqual( - span.startTimeUnixNano, - 1574120165429803008, - 'startTimeUnixNano is wrong' - ); - assert.strictEqual( - span.endTimeUnixNano, - 1574120165438688000, - 'endTimeUnixNano is wrong' - ); - assert.strictEqual( - span.droppedAttributesCount, - 0, - 'droppedAttributesCount is wrong' - ); - assert.strictEqual( - span.droppedEventsCount, - 0, - 'droppedEventsCount is wrong' - ); - assert.strictEqual( - span.droppedLinksCount, - 0, - 'droppedLinksCount is wrong' - ); - assert.deepStrictEqual( - span.status, - { code: 0, message: '' }, - 'status is' + ' wrong' - ); - }); - it('should convert span id', () => { - assert.deepStrictEqual(span.spanId, 'XhByYfZPpT4=', 'spanId is wrong'); - }); - it('should convert parent id', () => { - assert.deepStrictEqual( - span.parentSpanId, - 'eKiRUJiGQ4g=', - 'parentIdArr is wrong' - ); - }); - it('should convert name', () => { - assert.strictEqual(span.name, 'documentFetch', 'name is wrong'); - }); - it('should convert kind', () => { - assert.strictEqual( - span.kind, - opentelemetryProto.trace.v1.Span.SpanKind.INTERNAL, - 'kind is wrong' - ); - }); - it('should convert start time', () => { - assert.strictEqual( - span.startTimeUnixNano, - 1574120165429803008, - 'startTimeUnixNano is wrong' - ); - }); - it('should convert end time', () => { - assert.strictEqual( - span.endTimeUnixNano, - 1574120165438688000, - 'endTimeUnixNano is wrong' - ); - }); - it('should convert droppedAttributesCount', () => { - assert.strictEqual( - span.droppedAttributesCount, - 0, - 'droppedAttributesCount is wrong' - ); - }); - - it('should convert droppedEventsCount', () => { - assert.strictEqual( - span.droppedEventsCount, - 0, - 'droppedEventsCount is wrong' - ); - }); - - it('should convert droppedLinksCount', () => { - assert.strictEqual( - span.droppedLinksCount, - 0, - 'droppedLinksCount is wrong' - ); - }); - - it('should convert status', () => { - assert.deepStrictEqual( - span.status, - { code: 0, message: '' }, - 'status is' + ' wrong' - ); - }); - }); - - describe('toCollectorResource', () => { - it('should convert resource', () => { - const resource = transform.toCollectorResource( - new Resource({ - service: 'ui', - version: 1.0, - success: true, - }) - ); - assert.deepStrictEqual(resource.toObject(), { - attributesList: [ - { - key: 'service', - type: 0, - stringValue: 'ui', - intValue: 0, - doubleValue: 0, - boolValue: false, - }, - { - key: 'version', - type: 2, - stringValue: '', - intValue: 0, - doubleValue: 1, - boolValue: false, - }, - { - key: 'success', - type: 3, - stringValue: '', - intValue: 0, - doubleValue: 0, - boolValue: true, - }, - ], - droppedAttributesCount: 0, - }); - }); - }); -}); diff --git a/packages/opentelemetry-exporter-collector/tsconfig.json b/packages/opentelemetry-exporter-collector/tsconfig.json index 8d3779eda9..a2042cd68b 100644 --- a/packages/opentelemetry-exporter-collector/tsconfig.json +++ b/packages/opentelemetry-exporter-collector/tsconfig.json @@ -5,7 +5,6 @@ "outDir": "build" }, "include": [ - "generated/**/*.js", "src/**/*.ts", "test/**/*.ts" ] From 18b0745c002b531284cd0e87b4f20e8cdb6f369f Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Tue, 14 Jul 2020 01:01:04 +0200 Subject: [PATCH 08/10] chore: cleanup --- packages/opentelemetry-exporter-collector/package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/opentelemetry-exporter-collector/package.json b/packages/opentelemetry-exporter-collector/package.json index 91d8ff6518..1d44de7308 100644 --- a/packages/opentelemetry-exporter-collector/package.json +++ b/packages/opentelemetry-exporter-collector/package.json @@ -46,7 +46,6 @@ "build/src/**/*.js.map", "build/src/**/*.d.ts", "build/src/**/*.proto", - "build/generated/**/*.js", "doc", "LICENSE", "README.md" From 65b89e1ed1bbe379ae8ba0df56e9b4ab1310baa1 Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Tue, 21 Jul 2020 18:26:58 +0200 Subject: [PATCH 09/10] chore: fixes after merge --- .../src/platform/browser/CollectorTraceExporter.ts | 2 +- .../src/platform/node/CollectorMetricExporter.ts | 4 ++-- .../src/platform/node/CollectorTraceExporter.ts | 2 +- .../src/platform/node/utilWithGrpc.ts | 2 -- .../src/platform/node/utilWithJson.ts | 2 -- .../src/platform/node/utilWithJsonProto.ts | 7 ++----- .../test/node/CollectorMetricExporter.test.ts | 1 - 7 files changed, 6 insertions(+), 14 deletions(-) diff --git a/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorTraceExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorTraceExporter.ts index 6984c91cf7..6036fe3773 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorTraceExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorTraceExporter.ts @@ -22,8 +22,8 @@ import * as collectorTypes from '../../types'; import { sendWithBeacon, sendWithXhr } from './util'; import { parseHeaders } from '../../util'; -const DEFAULT_COLLECTOR_URL = 'http://localhost:55680/v1/trace'; const DEFAULT_SERVICE_NAME = 'collector-trace-exporter'; +const DEFAULT_COLLECTOR_URL = 'http://localhost:55680/v1/trace'; /** * Collector Trace Exporter for Web diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorMetricExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorMetricExporter.ts index cf84576055..fbf00089f8 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorMetricExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorMetricExporter.ts @@ -21,10 +21,10 @@ import { CollectorExporterConfigNode } from './types'; import { CollectorProtocolNode } from '../../enums'; import { CollectorExporterNodeBase } from './CollectorExporterNodeBase'; import { toCollectorExportMetricServiceRequest } from '../../transformMetrics'; -import { DEFAULT_COLLECTOR_URL_GRPC } from './utilWithGrpc'; -import { DEFAULT_COLLECTOR_URL_JSON } from './utilWithJson'; const DEFAULT_SERVICE_NAME = 'collector-metric-exporter'; +const DEFAULT_COLLECTOR_URL_GRPC = 'localhost:55680'; +const DEFAULT_COLLECTOR_URL_JSON = 'http://localhost:55680/v1/metrics'; /** * Collector Metric Exporter for Node diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts index aa167fcd77..2cabd1768c 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorTraceExporter.ts @@ -21,9 +21,9 @@ import * as collectorTypes from '../../types'; import { CollectorProtocolNode } from '../../enums'; import { CollectorExporterConfigNode } from './types'; import { toCollectorExportTraceServiceRequest } from '../../transform'; -import { DEFAULT_COLLECTOR_URL_GRPC } from './utilWithGrpc'; const DEFAULT_SERVICE_NAME = 'collector-trace-exporter'; +const DEFAULT_COLLECTOR_URL_GRPC = 'localhost:55680'; const DEFAULT_COLLECTOR_URL_JSON = 'http://localhost:55680/v1/trace'; const DEFAULT_COLLECTOR_URL_JSON_PROTO = 'http://localhost:55680/v1/trace'; diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithGrpc.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithGrpc.ts index fb02809e6d..8d1e3d1e33 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithGrpc.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithGrpc.ts @@ -24,8 +24,6 @@ import { CollectorExporterConfigNode, GRPCQueueItem } from './types'; import { removeProtocol } from './util'; import { CollectorExporterNodeBase } from './CollectorExporterNodeBase'; -export const DEFAULT_COLLECTOR_URL_GRPC = 'localhost:55680'; - export function initWithGrpc( collector: CollectorExporterNodeBase, config: CollectorExporterConfigNode diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts index 0e89abdee6..38da393cfe 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJson.ts @@ -19,8 +19,6 @@ import { CollectorExporterNodeBase } from './CollectorExporterNodeBase'; import { CollectorExporterConfigNode } from './types'; import { sendDataUsingHttp } from './util'; -export const DEFAULT_COLLECTOR_URL_JSON = 'http://localhost:55680/v1/metrics'; - export function initWithJson( _collector: CollectorExporterNodeBase, _config: CollectorExporterConfigNode diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts index 3685076d71..ba0035bb65 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/utilWithJsonProto.ts @@ -22,9 +22,6 @@ import { CollectorExporterNodeBase } from './CollectorExporterNodeBase'; import { CollectorExporterConfigNode } from './types'; import { sendDataUsingHttp } from './util'; -export const DEFAULT_COLLECTOR_URL_JSON_PROTO = - 'http://localhost:55680/v1/trace'; - let ExportTraceServiceRequestProto: Type | undefined; export function getExportTraceServiceRequestProto(): Type | undefined { @@ -73,7 +70,7 @@ export function sendWithJsonProto( } } else { onError({ - message: 'No proto' - }) + message: 'No proto', + }); } } diff --git a/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts b/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts index 2129c3df78..300c257593 100644 --- a/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/node/CollectorMetricExporter.test.ts @@ -174,7 +174,6 @@ const testCollectorMetricExporter = (params: TestParams) => assert.strictEqual(args[0], 'Headers cannot be set when using grpc'); }); it('should warn about metadata when using json', () => { - const metadata = new grpc.Metadata(); metadata.set('k', 'v'); const logger = new ConsoleLogger(LogLevel.DEBUG); From 09df9bc36ca4c7b40921186d1241cdc0cf44cc50 Mon Sep 17 00:00:00 2001 From: Bartlomiej Obecny Date: Wed, 22 Jul 2020 11:54:06 +0200 Subject: [PATCH 10/10] chore: clean up --- .../src/platform/node/README.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/README.md b/packages/opentelemetry-exporter-collector/src/platform/node/README.md index fe7705795e..66ca6c5f99 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/README.md +++ b/packages/opentelemetry-exporter-collector/src/platform/node/README.md @@ -43,6 +43,4 @@ the latest sha when this guide was written is `b54688569186e0b862bf7462a983ccf2c git commit -am "chore: updating submodule for opentelemetry-proto" ``` -9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one - -Make sure it compiles correctly. +9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one.