@miradorlabs/web-grpc 2.11.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miradorlabs/web-grpc",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Generated gRPC (grpc-js) client stubs for the Mirador web gateway.",
   "main": "index.js",
   "types": "index.d.ts",

package/proto/gateway/web/v1/trace_gateway.ts

@@ -1770,6 +1770,12 @@ export interface TraceEventEnvelope {
   spanId: string;
   /** Parent of this event's span ("" = root / trace-level) */
   parentSpanId: string;
+  /**
+   * Per-event annotations, rendered to strings server-side. Distinct from trace attributes
+   * (TraceStarted/AttributesUpdated) and span attributes (SpanStarted) — this bag belongs to
+   * this one event occurrence.
+   */
+  attributes: { [key: string]: string };
   traceStarted?: TraceStarted | undefined;
   traceFinished?: TraceFinished | undefined;
   infoEventAdded?: InfoEventAdded | undefined;
@@ -1823,6 +1829,11 @@ export interface TraceEventEnvelope {
   safeTxSuperseded?: SafeTxSuperseded | undefined;
 }
 
+export interface TraceEventEnvelope_AttributesEntry {
+  key: string;
+  value: string;
+}
+
 /** SpanStarted is emitted when a span opens. */
 export interface SpanStarted {
   /** the span that opened; same value as the envelope span_id (field 13) */
@@ -6758,6 +6769,7 @@ function createBaseTraceEventEnvelope(): TraceEventEnvelope {
     category: 0,
     spanId: "",
     parentSpanId: "",
+    attributes: {},
     traceStarted: undefined,
     traceFinished: undefined,
     infoEventAdded: undefined,
@@ -6850,6 +6862,9 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
     if (message.parentSpanId !== "") {
       writer.uint32(114).string(message.parentSpanId);
     }
+    globalThis.Object.entries(message.attributes).forEach(([key, value]: [string, string]) => {
+      TraceEventEnvelope_AttributesEntry.encode({ key: key as any, value }, writer.uint32(122).fork()).join();
+    });
     if (message.traceStarted !== undefined) {
       TraceStarted.encode(message.traceStarted, writer.uint32(162).fork()).join();
     }
@@ -7109,6 +7124,17 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
           message.parentSpanId = reader.string();
           continue;
         }
+        case 15: {
+          if (tag !== 122) {
+            break;
+          }
+
+          const entry15 = TraceEventEnvelope_AttributesEntry.decode(reader, reader.uint32());
+          if (entry15.value !== undefined) {
+            message.attributes[entry15.key] = entry15.value;
+          }
+          continue;
+        }
         case 20: {
           if (tag !== 162) {
             break;
@@ -7572,6 +7598,15 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
         : isSet(object.parent_span_id)
         ? globalThis.String(object.parent_span_id)
         : "",
+      attributes: isObject(object.attributes)
+        ? (globalThis.Object.entries(object.attributes) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
       traceStarted: isSet(object.traceStarted)
         ? TraceStarted.fromJSON(object.traceStarted)
         : isSet(object.trace_started)
@@ -7868,6 +7903,15 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
     if (message.parentSpanId !== "") {
       obj.parentSpanId = message.parentSpanId;
     }
+    if (message.attributes) {
+      const entries = globalThis.Object.entries(message.attributes) as [string, string][];
+      if (entries.length > 0) {
+        obj.attributes = {};
+        entries.forEach(([k, v]) => {
+          obj.attributes[k] = v;
+        });
+      }
+    }
     if (message.traceStarted !== undefined) {
       obj.traceStarted = TraceStarted.toJSON(message.traceStarted);
     }
@@ -8041,6 +8085,15 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
     message.category = object.category ?? 0;
     message.spanId = object.spanId ?? "";
     message.parentSpanId = object.parentSpanId ?? "";
+    message.attributes = (globalThis.Object.entries(object.attributes ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
     message.traceStarted = (object.traceStarted !== undefined && object.traceStarted !== null)
       ? TraceStarted.fromPartial(object.traceStarted)
       : undefined;
@@ -8207,6 +8260,86 @@ export const TraceEventEnvelope: MessageFns<TraceEventEnvelope> = {
   },
 };
 
+function createBaseTraceEventEnvelope_AttributesEntry(): TraceEventEnvelope_AttributesEntry {
+  return { key: "", value: "" };
+}
+
+export const TraceEventEnvelope_AttributesEntry: MessageFns<TraceEventEnvelope_AttributesEntry> = {
+  encode(message: TraceEventEnvelope_AttributesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TraceEventEnvelope_AttributesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTraceEventEnvelope_AttributesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TraceEventEnvelope_AttributesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: TraceEventEnvelope_AttributesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TraceEventEnvelope_AttributesEntry>, I>>(
+    base?: I,
+  ): TraceEventEnvelope_AttributesEntry {
+    return TraceEventEnvelope_AttributesEntry.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TraceEventEnvelope_AttributesEntry>, I>>(
+    object: I,
+  ): TraceEventEnvelope_AttributesEntry {
+    const message = createBaseTraceEventEnvelope_AttributesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
 function createBaseSpanStarted(): SpanStarted {
   return { spanId: "", parentSpanId: undefined, name: "", startTime: undefined, attributes: {} };
 }

package/proto/gateway/web/v1/trace_gateway_pb.js

@@ -9751,6 +9751,7 @@ source: jspb.Message.getFieldWithDefault(msg, 9, 0),
 category: jspb.Message.getFieldWithDefault(msg, 11, 0),
 spanId: jspb.Message.getFieldWithDefault(msg, 13, ""),
 parentSpanId: jspb.Message.getFieldWithDefault(msg, 14, ""),
+attributesMap: (f = msg.getAttributesMap()) ? f.toObject(includeInstance, undefined) : [],
 traceStarted: (f = msg.getTraceStarted()) && proto.gateway.web.v1.TraceStarted.toObject(includeInstance, f),
 traceFinished: (f = msg.getTraceFinished()) && proto.gateway.web.v1.TraceFinished.toObject(includeInstance, f),
 infoEventAdded: (f = msg.getInfoEventAdded()) && proto.gateway.web.v1.InfoEventAdded.toObject(includeInstance, f),
@@ -9888,6 +9889,12 @@ proto.gateway.web.v1.TraceEventEnvelope.deserializeBinaryFromReader = function(m
       var value = /** @type {string} */ (reader.readString());
       msg.setParentSpanId(value);
       break;
+    case 15:
+      var value = msg.getAttributesMap();
+      reader.readMessage(value, function(message, reader) {
+        jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", "");
+         });
+      break;
     case 20:
       var value = new proto.gateway.web.v1.TraceStarted;
       reader.readMessage(value,proto.gateway.web.v1.TraceStarted.deserializeBinaryFromReader);
@@ -10258,6 +10265,10 @@ proto.gateway.web.v1.TraceEventEnvelope.serializeBinaryToWriter = function(messa
       f
     );
   }
+  f = message.getAttributesMap(true);
+  if (f && f.getLength() > 0) {
+    f.serializeBinary(15, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString);
+  }
   f = message.getTraceStarted();
   if (f != null) {
     writer.writeMessage(
@@ -10923,6 +10934,29 @@ proto.gateway.web.v1.TraceEventEnvelope.prototype.setParentSpanId = function(val
 };
 
 
+/**
+ * map<string, string> attributes = 15;
+ * @param {boolean=} opt_noLazyCreate Do not create the map if
+ * empty, instead returning `undefined`
+ * @return {!jspb.Map<string,string>}
+ */
+proto.gateway.web.v1.TraceEventEnvelope.prototype.getAttributesMap = function(opt_noLazyCreate) {
+  return /** @type {!jspb.Map<string,string>} */ (
+      jspb.Message.getMapField(this, 15, opt_noLazyCreate,
+      null));
+};
+
+
+/**
+ * Clears values from the map. The map will be non-null.
+ * @return {!proto.gateway.web.v1.TraceEventEnvelope} returns this
+ */
+proto.gateway.web.v1.TraceEventEnvelope.prototype.clearAttributesMap = function() {
+  this.getAttributesMap().clear();
+  return this;
+};
+
+
 /**
  * optional TraceStarted trace_started = 20;
  * @return {?proto.gateway.web.v1.TraceStarted}