@zhijianma/studio 1.0.10

package/dist/server/src/models/Trace.js

@@ -0,0 +1,154 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanTable = void 0;
+const typeorm_1 = require("typeorm");
+// Span table - optimized for trace listing and filtering
+let SpanTable = class SpanTable extends typeorm_1.BaseEntity {
+};
+exports.SpanTable = SpanTable;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ nullable: false }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], SpanTable.prototype, "traceId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], SpanTable.prototype, "spanId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "traceState", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "parentSpanId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "flags", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], SpanTable.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "kind", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], SpanTable.prototype, "startTimeUnixNano", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], SpanTable.prototype, "endTimeUnixNano", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json'),
+    __metadata("design:type", Object)
+], SpanTable.prototype, "attributes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "droppedAttributesCount", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json', { nullable: true }),
+    __metadata("design:type", Array)
+], SpanTable.prototype, "events", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "droppedEventsCount", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json', { nullable: true }),
+    __metadata("design:type", Array)
+], SpanTable.prototype, "links", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "droppedLinksCount", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json'),
+    __metadata("design:type", Object)
+], SpanTable.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json'),
+    __metadata("design:type", Object)
+], SpanTable.prototype, "resource", void 0);
+__decorate([
+    (0, typeorm_1.Column)('json'),
+    __metadata("design:type", Object)
+], SpanTable.prototype, "scope", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "statusCode", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "serviceName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "operationName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "instrumentationName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "instrumentationVersion", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "model", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "inputTokens", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "outputTokens", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "totalTokens", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SpanTable.prototype, "conversationId", void 0);
+__decorate([
+    (0, typeorm_1.Column)('float'),
+    __metadata("design:type", Number)
+], SpanTable.prototype, "latencyNs", void 0);
+exports.SpanTable = SpanTable = __decorate([
+    (0, typeorm_1.Entity)(),
+    (0, typeorm_1.Index)(['traceId']),
+    (0, typeorm_1.Index)(['spanId']),
+    (0, typeorm_1.Index)(['parentSpanId']),
+    (0, typeorm_1.Index)(['startTimeUnixNano']),
+    (0, typeorm_1.Index)(['statusCode']),
+    (0, typeorm_1.Index)(['latencyNs']),
+    (0, typeorm_1.Index)(['serviceName']),
+    (0, typeorm_1.Index)(['operationName']),
+    (0, typeorm_1.Index)(['instrumentationName']),
+    (0, typeorm_1.Index)(['model']),
+    (0, typeorm_1.Index)(['inputTokens']),
+    (0, typeorm_1.Index)(['outputTokens']),
+    (0, typeorm_1.Index)(['totalTokens']),
+    (0, typeorm_1.Index)(['conversationId'])
+], SpanTable);

package/dist/server/src/otel/grpc-server.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelGrpcServer = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const Trace_1 = require("../dao/Trace");
+const socket_1 = require("../trpc/socket");
+const trace_service_1 = require("./opentelemetry/proto/collector/trace/v1/trace_service");
+const processor_1 = require("./processor");
+/**
+ * gRPC server implementation for OpenTelemetry TraceService
+ */
+class OtelGrpcServer {
+    constructor(defaultPort = 4317) {
+        this.defaultPort = defaultPort;
+        this.server = new grpc.Server();
+        this.setupService();
+    }
+    setupService() {
+        // Create TraceService implementation
+        const traceServiceImpl = {
+            Export: this.handleExport.bind(this),
+        };
+        // Add the service to the server
+        this.server.addService(trace_service_1.opentelemetry.proto.collector.trace.v1
+            .UnimplementedTraceServiceService.definition, traceServiceImpl);
+    }
+    /**
+     * Handle Export RPC call
+     */
+    handleExport(call, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.debug('[OTEL gRPC] Received ExportTraceServiceRequest');
+                const request = call.request;
+                const resourceSpans = request.resource_spans || [];
+                if (resourceSpans.length === 0) {
+                    console.warn('[OTEL gRPC] Empty resource_spans in request');
+                    const response = new trace_service_1.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse();
+                    callback(null, response);
+                    return;
+                }
+                // Convert ResourceSpans to plain objects for processing
+                const resourceSpansArray = resourceSpans.map((rs) => rs.toObject());
+                // Process spans using the existing processor
+                const spans = processor_1.SpanProcessor.batchProcessOTLPTraces(resourceSpansArray);
+                // Save spans to the database
+                yield Trace_1.SpanDao.saveSpans(spans);
+                // Broadcast spans to the run room
+                socket_1.SocketManager.broadcastSpanDataToRunRoom(spans);
+                console.debug(`[OTEL gRPC] Successfully processed ${spans.length} spans`);
+                // Create success response
+                const response = new trace_service_1.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse();
+                callback(null, response);
+            }
+            catch (error) {
+                console.error('[OTEL gRPC] Error processing traces:', error);
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const response = new trace_service_1.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse();
+                const partialSuccess = new trace_service_1.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess();
+                partialSuccess.error_message = errorMessage;
+                response.partial_success = partialSuccess;
+                callback({
+                    code: grpc.status.INTERNAL,
+                    details: errorMessage,
+                    metadata: new grpc.Metadata(),
+                }, response);
+            }
+        });
+    }
+    /**
+     * Start the gRPC server
+     * @param port - Port to bind the server to. If not provided, uses the default port from constructor.
+     */
+    start(port) {
+        const bindPort = port !== null && port !== void 0 ? port : this.defaultPort;
+        return new Promise((resolve, reject) => {
+            this.server.bindAsync(`0.0.0.0:${bindPort}`, grpc.ServerCredentials.createInsecure(), (error) => {
+                if (error) {
+                    console.error(`[OTEL gRPC] Failed to start server on port ${bindPort}:`, error);
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the gRPC server
+     */
+    stop() {
+        return new Promise((resolve, reject) => {
+            this.server.tryShutdown((error) => {
+                if (error) {
+                    console.error('[OTEL gRPC] Error shutting down server:', error);
+                    reject(error);
+                }
+                else {
+                    console.debug('[OTEL gRPC] Server stopped');
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Force shutdown the gRPC server
+     */
+    forceShutdown() {
+        this.server.forceShutdown();
+        console.debug('[OTEL gRPC] Server force shutdown');
+    }
+}
+exports.OtelGrpcServer = OtelGrpcServer;

package/dist/server/src/otel/opentelemetry/proto/collector/trace/v1/trace_service.js

@@ -0,0 +1,309 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opentelemetry = void 0;
+/**
+ * Generated by the protoc-gen-ts.  DO NOT EDIT!
+ * compiler version: 5.27.0
+ * source: opentelemetry/proto/collector/trace/v1/trace_service.proto
+ * git: https://github.com/thesayyn/protoc-gen-ts */
+const grpc_1 = __importStar(require("@grpc/grpc-js"));
+const pb_1 = __importStar(require("google-protobuf"));
+const dependency_1 = __importStar(require("../../../trace/v1/trace"));
+var opentelemetry;
+(function (opentelemetry) {
+    var proto;
+    (function (proto) {
+        var collector;
+        (function (collector) {
+            var trace;
+            (function (trace) {
+                var v1;
+                (function (v1) {
+                    var _ExportTraceServiceRequest_one_of_decls, _ExportTraceServiceResponse_one_of_decls, _ExportTracePartialSuccess_one_of_decls;
+                    class ExportTraceServiceRequest extends pb_1.Message {
+                        constructor(data) {
+                            super();
+                            _ExportTraceServiceRequest_one_of_decls.set(this, []);
+                            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], __classPrivateFieldGet(this, _ExportTraceServiceRequest_one_of_decls, "f"));
+                            if (!Array.isArray(data) && typeof data == 'object') {
+                                if ('resource_spans' in data &&
+                                    data.resource_spans != undefined) {
+                                    this.resource_spans = data.resource_spans;
+                                }
+                            }
+                        }
+                        get resource_spans() {
+                            return pb_1.Message.getRepeatedWrapperField(this, dependency_1.opentelemetry.proto.trace.v1.ResourceSpans, 1);
+                        }
+                        set resource_spans(value) {
+                            pb_1.Message.setRepeatedWrapperField(this, 1, value);
+                        }
+                        static fromObject(data) {
+                            const message = new ExportTraceServiceRequest({});
+                            if (data.resource_spans != null) {
+                                message.resource_spans = data.resource_spans.map((item) => dependency_1.opentelemetry.proto.trace.v1.ResourceSpans.fromObject(item));
+                            }
+                            return message;
+                        }
+                        toObject() {
+                            const data = {};
+                            if (this.resource_spans != null) {
+                                data.resource_spans = this.resource_spans.map((item) => item.toObject());
+                            }
+                            return data;
+                        }
+                        serialize(w) {
+                            const writer = w || new pb_1.BinaryWriter();
+                            if (this.resource_spans.length)
+                                writer.writeRepeatedMessage(1, this.resource_spans, (item) => item.serialize(writer));
+                            if (!w)
+                                return writer.getResultBuffer();
+                        }
+                        static deserialize(bytes) {
+                            const reader = bytes instanceof pb_1.BinaryReader
+                                ? bytes
+                                : new pb_1.BinaryReader(bytes), message = new ExportTraceServiceRequest();
+                            while (reader.nextField()) {
+                                if (reader.isEndGroup())
+                                    break;
+                                switch (reader.getFieldNumber()) {
+                                    case 1:
+                                        reader.readMessage(message.resource_spans, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_1.opentelemetry.proto.trace.v1.ResourceSpans.deserialize(reader), dependency_1.opentelemetry.proto.trace.v1
+                                            .ResourceSpans));
+                                        break;
+                                    default:
+                                        reader.skipField();
+                                }
+                            }
+                            return message;
+                        }
+                        serializeBinary() {
+                            return this.serialize();
+                        }
+                        static deserializeBinary(bytes) {
+                            return ExportTraceServiceRequest.deserialize(bytes);
+                        }
+                    }
+                    _ExportTraceServiceRequest_one_of_decls = new WeakMap();
+                    v1.ExportTraceServiceRequest = ExportTraceServiceRequest;
+                    class ExportTraceServiceResponse extends pb_1.Message {
+                        constructor(data) {
+                            super();
+                            _ExportTraceServiceResponse_one_of_decls.set(this, []);
+                            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], __classPrivateFieldGet(this, _ExportTraceServiceResponse_one_of_decls, "f"));
+                            if (!Array.isArray(data) && typeof data == 'object') {
+                                if ('partial_success' in data &&
+                                    data.partial_success != undefined) {
+                                    this.partial_success = data.partial_success;
+                                }
+                            }
+                        }
+                        get partial_success() {
+                            return pb_1.Message.getWrapperField(this, ExportTracePartialSuccess, 1);
+                        }
+                        set partial_success(value) {
+                            pb_1.Message.setWrapperField(this, 1, value);
+                        }
+                        get has_partial_success() {
+                            return pb_1.Message.getField(this, 1) != null;
+                        }
+                        static fromObject(data) {
+                            const message = new ExportTraceServiceResponse({});
+                            if (data.partial_success != null) {
+                                message.partial_success = ExportTracePartialSuccess.fromObject(data.partial_success);
+                            }
+                            return message;
+                        }
+                        toObject() {
+                            const data = {};
+                            if (this.partial_success != null) {
+                                data.partial_success = this.partial_success.toObject();
+                            }
+                            return data;
+                        }
+                        serialize(w) {
+                            const writer = w || new pb_1.BinaryWriter();
+                            if (this.has_partial_success)
+                                writer.writeMessage(1, this.partial_success, () => this.partial_success.serialize(writer));
+                            if (!w)
+                                return writer.getResultBuffer();
+                        }
+                        static deserialize(bytes) {
+                            const reader = bytes instanceof pb_1.BinaryReader
+                                ? bytes
+                                : new pb_1.BinaryReader(bytes), message = new ExportTraceServiceResponse();
+                            while (reader.nextField()) {
+                                if (reader.isEndGroup())
+                                    break;
+                                switch (reader.getFieldNumber()) {
+                                    case 1:
+                                        reader.readMessage(message.partial_success, () => (message.partial_success =
+                                            ExportTracePartialSuccess.deserialize(reader)));
+                                        break;
+                                    default:
+                                        reader.skipField();
+                                }
+                            }
+                            return message;
+                        }
+                        serializeBinary() {
+                            return this.serialize();
+                        }
+                        static deserializeBinary(bytes) {
+                            return ExportTraceServiceResponse.deserialize(bytes);
+                        }
+                    }
+                    _ExportTraceServiceResponse_one_of_decls = new WeakMap();
+                    v1.ExportTraceServiceResponse = ExportTraceServiceResponse;
+                    class ExportTracePartialSuccess extends pb_1.Message {
+                        constructor(data) {
+                            super();
+                            _ExportTracePartialSuccess_one_of_decls.set(this, []);
+                            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], __classPrivateFieldGet(this, _ExportTracePartialSuccess_one_of_decls, "f"));
+                            if (!Array.isArray(data) && typeof data == 'object') {
+                                if ('rejected_spans' in data &&
+                                    data.rejected_spans != undefined) {
+                                    this.rejected_spans = data.rejected_spans;
+                                }
+                                if ('error_message' in data &&
+                                    data.error_message != undefined) {
+                                    this.error_message = data.error_message;
+                                }
+                            }
+                        }
+                        get rejected_spans() {
+                            return pb_1.Message.getFieldWithDefault(this, 1, 0);
+                        }
+                        set rejected_spans(value) {
+                            pb_1.Message.setField(this, 1, value);
+                        }
+                        get error_message() {
+                            return pb_1.Message.getFieldWithDefault(this, 2, '');
+                        }
+                        set error_message(value) {
+                            pb_1.Message.setField(this, 2, value);
+                        }
+                        static fromObject(data) {
+                            const message = new ExportTracePartialSuccess({});
+                            if (data.rejected_spans != null) {
+                                message.rejected_spans = data.rejected_spans;
+                            }
+                            if (data.error_message != null) {
+                                message.error_message = data.error_message;
+                            }
+                            return message;
+                        }
+                        toObject() {
+                            const data = {};
+                            if (this.rejected_spans != null) {
+                                data.rejected_spans = this.rejected_spans;
+                            }
+                            if (this.error_message != null) {
+                                data.error_message = this.error_message;
+                            }
+                            return data;
+                        }
+                        serialize(w) {
+                            const writer = w || new pb_1.BinaryWriter();
+                            if (this.rejected_spans != 0)
+                                writer.writeInt64(1, this.rejected_spans);
+                            if (this.error_message.length)
+                                writer.writeString(2, this.error_message);
+                            if (!w)
+                                return writer.getResultBuffer();
+                        }
+                        static deserialize(bytes) {
+                            const reader = bytes instanceof pb_1.BinaryReader
+                                ? bytes
+                                : new pb_1.BinaryReader(bytes), message = new ExportTracePartialSuccess();
+                            while (reader.nextField()) {
+                                if (reader.isEndGroup())
+                                    break;
+                                switch (reader.getFieldNumber()) {
+                                    case 1:
+                                        message.rejected_spans = reader.readInt64();
+                                        break;
+                                    case 2:
+                                        message.error_message = reader.readString();
+                                        break;
+                                    default:
+                                        reader.skipField();
+                                }
+                            }
+                            return message;
+                        }
+                        serializeBinary() {
+                            return this.serialize();
+                        }
+                        static deserializeBinary(bytes) {
+                            return ExportTracePartialSuccess.deserialize(bytes);
+                        }
+                    }
+                    _ExportTracePartialSuccess_one_of_decls = new WeakMap();
+                    v1.ExportTracePartialSuccess = ExportTracePartialSuccess;
+                    class UnimplementedTraceServiceService {
+                    }
+                    UnimplementedTraceServiceService.definition = {
+                        Export: {
+                            path: '/opentelemetry.proto.collector.trace.v1.TraceService/Export',
+                            requestStream: false,
+                            responseStream: false,
+                            requestSerialize: (message) => Buffer.from(message.serialize()),
+                            requestDeserialize: (bytes) => ExportTraceServiceRequest.deserialize(new Uint8Array(bytes)),
+                            responseSerialize: (message) => Buffer.from(message.serialize()),
+                            responseDeserialize: (bytes) => ExportTraceServiceResponse.deserialize(new Uint8Array(bytes)),
+                        },
+                    };
+                    v1.UnimplementedTraceServiceService = UnimplementedTraceServiceService;
+                    class TraceServiceClient extends grpc_1.makeGenericClientConstructor(UnimplementedTraceServiceService.definition, 'TraceService', {}) {
+                        constructor(address, credentials, options) {
+                            super(address, credentials, options);
+                            this.Export = (message, metadata, options, callback) => {
+                                return super.Export(message, metadata, options, callback);
+                            };
+                        }
+                    }
+                    v1.TraceServiceClient = TraceServiceClient;
+                })(v1 = trace.v1 || (trace.v1 = {}));
+            })(trace = collector.trace || (collector.trace = {}));
+        })(collector = proto.collector || (proto.collector = {}));
+    })(proto = opentelemetry.proto || (opentelemetry.proto = {}));
+})(opentelemetry || (exports.opentelemetry = opentelemetry = {}));