@miradorlabs/web-grpc 2.68.0 → 2.71.0

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

@@ -313,6 +313,36 @@ export interface QuerySeriesUpdate_GroupValuesEntry {
   value: string;
 }
 
+export interface BatchQueryRequest {
+  /** Verified against the caller's identity before proxying. */
+  organizationId: string;
+  projectId: string;
+  /**
+   * 1-50 queries, each id nonempty, unique within the request, and bounded in
+   * length; violations are rejected before any query runs.
+   */
+  queries: BatchQueryItem[];
+}
+
+/**
+ * BatchQueryItem is one query in the batch. Same fields as StreamQueryRequest's
+ * query half, plus a client-supplied id echoed back on its outcome.
+ */
+export interface BatchQueryItem {
+  /** Client-generated, echoed verbatim on this query's outcome envelope. */
+  id: string;
+  promql: string;
+  timeRange: TimeRange | undefined;
+  timeInterval: AnalyticsTimeInterval;
+}
+
+/** BatchQueryEnvelope is one query's terminal outcome, tagged with its id. */
+export interface BatchQueryEnvelope {
+  id: string;
+  snapshot?: QuerySnapshot | undefined;
+  error?: WidgetQueryError | undefined;
+}
+
 /**
  * Dashboard is the saved document. Server-enforced caps: ≤24 widgets per
  * dashboard, ≤4 queries per widget.
@@ -2379,6 +2409,349 @@ export const QuerySeriesUpdate_GroupValuesEntry: MessageFns<QuerySeriesUpdate_Gr
   },
 };
 
+function createBaseBatchQueryRequest(): BatchQueryRequest {
+  return { organizationId: "", projectId: "", queries: [] };
+}
+
+export const BatchQueryRequest: MessageFns<BatchQueryRequest> = {
+  encode(message: BatchQueryRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
+    for (const v of message.queries) {
+      BatchQueryItem.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BatchQueryRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseBatchQueryRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.projectId = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.queries.push(BatchQueryItem.decode(reader, reader.uint32()));
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): BatchQueryRequest {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      queries: globalThis.Array.isArray(object?.queries)
+        ? object.queries.map((e: any) => BatchQueryItem.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: BatchQueryRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.queries?.length) {
+      obj.queries = message.queries.map((e) => BatchQueryItem.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<BatchQueryRequest>, I>>(base?: I): BatchQueryRequest {
+    return BatchQueryRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<BatchQueryRequest>, I>>(object: I): BatchQueryRequest {
+    const message = createBaseBatchQueryRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.queries = object.queries?.map((e) => BatchQueryItem.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseBatchQueryItem(): BatchQueryItem {
+  return { id: "", promql: "", timeRange: undefined, timeInterval: 0 };
+}
+
+export const BatchQueryItem: MessageFns<BatchQueryItem> = {
+  encode(message: BatchQueryItem, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.promql !== "") {
+      writer.uint32(18).string(message.promql);
+    }
+    if (message.timeRange !== undefined) {
+      TimeRange.encode(message.timeRange, writer.uint32(26).fork()).join();
+    }
+    if (message.timeInterval !== 0) {
+      writer.uint32(32).int32(message.timeInterval);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BatchQueryItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseBatchQueryItem();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.id = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.promql = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.timeRange = TimeRange.decode(reader, reader.uint32());
+            continue;
+          }
+          case 4: {
+            if (tag !== 32) {
+              break;
+            }
+
+            message.timeInterval = reader.int32() as any;
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): BatchQueryItem {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      promql: isSet(object.promql) ? globalThis.String(object.promql) : "",
+      timeRange: isSet(object.timeRange)
+        ? TimeRange.fromJSON(object.timeRange)
+        : isSet(object.time_range)
+        ? TimeRange.fromJSON(object.time_range)
+        : undefined,
+      timeInterval: isSet(object.timeInterval)
+        ? analyticsTimeIntervalFromJSON(object.timeInterval)
+        : isSet(object.time_interval)
+        ? analyticsTimeIntervalFromJSON(object.time_interval)
+        : 0,
+    };
+  },
+
+  toJSON(message: BatchQueryItem): unknown {
+    const obj: any = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.promql !== "") {
+      obj.promql = message.promql;
+    }
+    if (message.timeRange !== undefined) {
+      obj.timeRange = TimeRange.toJSON(message.timeRange);
+    }
+    if (message.timeInterval !== 0) {
+      obj.timeInterval = analyticsTimeIntervalToJSON(message.timeInterval);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<BatchQueryItem>, I>>(base?: I): BatchQueryItem {
+    return BatchQueryItem.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<BatchQueryItem>, I>>(object: I): BatchQueryItem {
+    const message = createBaseBatchQueryItem();
+    message.id = object.id ?? "";
+    message.promql = object.promql ?? "";
+    message.timeRange = (object.timeRange !== undefined && object.timeRange !== null)
+      ? TimeRange.fromPartial(object.timeRange)
+      : undefined;
+    message.timeInterval = object.timeInterval ?? 0;
+    return message;
+  },
+};
+
+function createBaseBatchQueryEnvelope(): BatchQueryEnvelope {
+  return { id: "", snapshot: undefined, error: undefined };
+}
+
+export const BatchQueryEnvelope: MessageFns<BatchQueryEnvelope> = {
+  encode(message: BatchQueryEnvelope, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.snapshot !== undefined) {
+      QuerySnapshot.encode(message.snapshot, writer.uint32(18).fork()).join();
+    }
+    if (message.error !== undefined) {
+      WidgetQueryError.encode(message.error, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BatchQueryEnvelope {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseBatchQueryEnvelope();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.id = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.snapshot = QuerySnapshot.decode(reader, reader.uint32());
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.error = WidgetQueryError.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): BatchQueryEnvelope {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      snapshot: isSet(object.snapshot) ? QuerySnapshot.fromJSON(object.snapshot) : undefined,
+      error: isSet(object.error) ? WidgetQueryError.fromJSON(object.error) : undefined,
+    };
+  },
+
+  toJSON(message: BatchQueryEnvelope): unknown {
+    const obj: any = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.snapshot !== undefined) {
+      obj.snapshot = QuerySnapshot.toJSON(message.snapshot);
+    }
+    if (message.error !== undefined) {
+      obj.error = WidgetQueryError.toJSON(message.error);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<BatchQueryEnvelope>, I>>(base?: I): BatchQueryEnvelope {
+    return BatchQueryEnvelope.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<BatchQueryEnvelope>, I>>(object: I): BatchQueryEnvelope {
+    const message = createBaseBatchQueryEnvelope();
+    message.id = object.id ?? "";
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? QuerySnapshot.fromPartial(object.snapshot)
+      : undefined;
+    message.error = (object.error !== undefined && object.error !== null)
+      ? WidgetQueryError.fromPartial(object.error)
+      : undefined;
+    return message;
+  },
+};
+
 function createBaseDashboard(): Dashboard {
   return {
     id: "",
@@ -5207,6 +5580,15 @@ export interface MetricGatewayService {
    * the snapshot). Query failures abort the stream with a gRPC status.
    */
   StreamQuery(request: StreamQueryRequest, metadata?: Metadata): Observable<QueryDataEnvelope>;
+  /**
+   * Batched ad-hoc query execution: N id-tagged PromQL queries over one stream,
+   * each evaluated snapshot-once, each delivered as its own envelope as it
+   * resolves. Exactly one outcome (snapshot or in-band error) per accepted id, no
+   * ordering guarantee; a per-query failure is in-band and never ends the stream.
+   * EOF means every accepted id has returned. See the telemetry-api service
+   * definition for the full ordering/cardinality guarantees.
+   */
+  BatchQuery(request: BatchQueryRequest, metadata?: Metadata): Observable<BatchQueryEnvelope>;
   CreateDashboard(request: CreateDashboardRequest, metadata?: Metadata): Promise<CreateDashboardResponse>;
   GetDashboard(request: GetDashboardRequest, metadata?: Metadata): Promise<GetDashboardResponse>;
   ListDashboards(request: ListDashboardsRequest, metadata?: Metadata): Promise<ListDashboardsResponse>;
@@ -5244,6 +5626,7 @@ export class MetricGatewayServiceClientImpl implements MetricGatewayService {
     this.StreamMetrics = this.StreamMetrics.bind(this);
     this.StreamMetricAttributes = this.StreamMetricAttributes.bind(this);
     this.StreamQuery = this.StreamQuery.bind(this);
+    this.BatchQuery = this.BatchQuery.bind(this);
     this.CreateDashboard = this.CreateDashboard.bind(this);
     this.GetDashboard = this.GetDashboard.bind(this);
     this.ListDashboards = this.ListDashboards.bind(this);
@@ -5273,6 +5656,12 @@ export class MetricGatewayServiceClientImpl implements MetricGatewayService {
     return result.pipe(map((data) => QueryDataEnvelope.decode(new BinaryReader(data))));
   }
 
+  BatchQuery(request: BatchQueryRequest, metadata?: Metadata): Observable<BatchQueryEnvelope> {
+    const data = BatchQueryRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "BatchQuery", data, metadata);
+    return result.pipe(map((data) => BatchQueryEnvelope.decode(new BinaryReader(data))));
+  }
+
   CreateDashboard(request: CreateDashboardRequest, metadata?: Metadata): Promise<CreateDashboardResponse> {
     const data = CreateDashboardRequest.encode(request).finish();
     const promise = this.rpc.request(this.service, "CreateDashboard", data, metadata);

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

@@ -7,6 +7,28 @@ var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/time
 var proto_gateway_common_v1_status_pb = require('../../../../proto/gateway/common/v1/status_pb.js');
 var proto_gateway_web_v1_trace_gateway_pb = require('../../../../proto/gateway/web/v1/trace_gateway_pb.js');
 
+function serialize_gateway_web_v1_BatchQueryEnvelope(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.BatchQueryEnvelope)) {
+    throw new Error('Expected argument of type gateway.web.v1.BatchQueryEnvelope');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_BatchQueryEnvelope(buffer_arg) {
+  return proto_gateway_web_v1_metric_gateway_pb.BatchQueryEnvelope.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gateway_web_v1_BatchQueryRequest(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.BatchQueryRequest)) {
+    throw new Error('Expected argument of type gateway.web.v1.BatchQueryRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_BatchQueryRequest(buffer_arg) {
+  return proto_gateway_web_v1_metric_gateway_pb.BatchQueryRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_gateway_web_v1_CreateDashboardRequest(arg) {
   if (!(arg instanceof proto_gateway_web_v1_metric_gateway_pb.CreateDashboardRequest)) {
     throw new Error('Expected argument of type gateway.web.v1.CreateDashboardRequest');
@@ -273,6 +295,23 @@ streamQuery: {
     responseSerialize: serialize_gateway_web_v1_QueryDataEnvelope,
     responseDeserialize: deserialize_gateway_web_v1_QueryDataEnvelope,
   },
+  // Batched ad-hoc query execution: N id-tagged PromQL queries over one stream,
+// each evaluated snapshot-once, each delivered as its own envelope as it
+// resolves. Exactly one outcome (snapshot or in-band error) per accepted id, no
+// ordering guarantee; a per-query failure is in-band and never ends the stream.
+// EOF means every accepted id has returned. See the telemetry-api service
+// definition for the full ordering/cardinality guarantees.
+batchQuery: {
+    path: '/gateway.web.v1.MetricGatewayService/BatchQuery',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_gateway_web_v1_metric_gateway_pb.BatchQueryRequest,
+    responseType: proto_gateway_web_v1_metric_gateway_pb.BatchQueryEnvelope,
+    requestSerialize: serialize_gateway_web_v1_BatchQueryRequest,
+    requestDeserialize: deserialize_gateway_web_v1_BatchQueryRequest,
+    responseSerialize: serialize_gateway_web_v1_BatchQueryEnvelope,
+    responseDeserialize: deserialize_gateway_web_v1_BatchQueryEnvelope,
+  },
   createDashboard: {
     path: '/gateway.web.v1.MetricGatewayService/CreateDashboard',
     requestStream: false,