@miradorlabs/web-grpc 2.9.0 → 2.11.0

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

@@ -12,6 +12,43 @@ import { ResponseStatus } from "../../common/v1/status";
 
 export const protobufPackage = "gateway.web.v1";
 
+/**
+ * The signal a definition derives from. Log and metric sources are planned and will be added as
+ * new values; unset reads as TRACE.
+ */
+export enum DerivedMetricSource {
+  DERIVED_METRIC_SOURCE_UNSPECIFIED = 0,
+  DERIVED_METRIC_SOURCE_TRACE = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function derivedMetricSourceFromJSON(object: any): DerivedMetricSource {
+  switch (object) {
+    case 0:
+    case "DERIVED_METRIC_SOURCE_UNSPECIFIED":
+      return DerivedMetricSource.DERIVED_METRIC_SOURCE_UNSPECIFIED;
+    case 1:
+    case "DERIVED_METRIC_SOURCE_TRACE":
+      return DerivedMetricSource.DERIVED_METRIC_SOURCE_TRACE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return DerivedMetricSource.UNRECOGNIZED;
+  }
+}
+
+export function derivedMetricSourceToJSON(object: DerivedMetricSource): string {
+  switch (object) {
+    case DerivedMetricSource.DERIVED_METRIC_SOURCE_UNSPECIFIED:
+      return "DERIVED_METRIC_SOURCE_UNSPECIFIED";
+    case DerivedMetricSource.DERIVED_METRIC_SOURCE_TRACE:
+      return "DERIVED_METRIC_SOURCE_TRACE";
+    case DerivedMetricSource.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum DerivedMetricOutcome {
   DERIVED_METRIC_OUTCOME_UNSPECIFIED = 0,
   DERIVED_METRIC_OUTCOME_EMITTED = 1,
@@ -113,6 +150,64 @@ export function derivedMetricOutcomeToJSON(object: DerivedMetricOutcome): string
   }
 }
 
+export enum DerivedMetricAttributeType {
+  DERIVED_METRIC_ATTRIBUTE_TYPE_UNSPECIFIED = 0,
+  DERIVED_METRIC_ATTRIBUTE_TYPE_STRING = 1,
+  DERIVED_METRIC_ATTRIBUTE_TYPE_BOOL = 2,
+  DERIVED_METRIC_ATTRIBUTE_TYPE_INT = 3,
+  DERIVED_METRIC_ATTRIBUTE_TYPE_DOUBLE = 4,
+  /** DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED - The key was observed with more than one type across traces. */
+  DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED = 5,
+  UNRECOGNIZED = -1,
+}
+
+export function derivedMetricAttributeTypeFromJSON(object: any): DerivedMetricAttributeType {
+  switch (object) {
+    case 0:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_UNSPECIFIED":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_UNSPECIFIED;
+    case 1:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_STRING":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_STRING;
+    case 2:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_BOOL":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_BOOL;
+    case 3:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_INT":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_INT;
+    case 4:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_DOUBLE":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_DOUBLE;
+    case 5:
+    case "DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED":
+      return DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return DerivedMetricAttributeType.UNRECOGNIZED;
+  }
+}
+
+export function derivedMetricAttributeTypeToJSON(object: DerivedMetricAttributeType): string {
+  switch (object) {
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_UNSPECIFIED:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_UNSPECIFIED";
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_STRING:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_STRING";
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_BOOL:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_BOOL";
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_INT:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_INT";
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_DOUBLE:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_DOUBLE";
+    case DerivedMetricAttributeType.DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED:
+      return "DERIVED_METRIC_ATTRIBUTE_TYPE_MIXED";
+    case DerivedMetricAttributeType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface DerivedMetric {
   id: string;
   organizationId: string;
@@ -128,6 +223,7 @@ export interface DerivedMetric {
   program: DerivedMetricProgram | undefined;
   createdAt: Date | undefined;
   updatedAt: Date | undefined;
+  source: DerivedMetricSource;
 }
 
 export interface DerivedMetricProgram {
@@ -140,10 +236,13 @@ export interface DerivedMetricProgram {
   /** Evaluates to a number, or to an empty optional meaning no sample. */
   valueExpression: string;
   /**
-   * Optional. Evaluates to a string selecting the series -- one series per distinct value, the same
-   * way any other metric groups. Empty, or unresolved, yields one unlabelled series.
+   * Trace attribute keys stamped onto every emitted point, so any dashboard widget can group or
+   * filter by any of them at read time -- one measurement, many groupings. At most four (the read
+   * side resolves four group-by keys). Values render canonically; a missing attribute becomes the
+   * empty string, never a dropped sample. Immutable after create: changing dimensions rewrites
+   * every series identity.
    */
-  groupByExpression: string;
+  dimensions: string[];
 }
 
 export interface CreateDerivedMetricRequest {
@@ -155,6 +254,7 @@ export interface CreateDerivedMetricRequest {
   enabled: boolean;
   unit: string;
   program: DerivedMetricProgram | undefined;
+  source: DerivedMetricSource;
 }
 
 export interface CreateDerivedMetricResponse {
@@ -196,7 +296,7 @@ export interface UpdateDerivedMetricRequest_DerivedMetricUpdates {
     | string
     | undefined;
   /**
-   * The measurement (population, value, group-by, unit, slug) is immutable -- changing it
+   * The measurement (population, value, dimensions, unit, slug) is immutable -- changing it
    * means a new metric.
    */
   enabled?: boolean | undefined;
@@ -249,8 +349,16 @@ export interface DryRunTraceResult {
 
 export interface DryRunEmission {
   value: number;
-  /** The series this trace would land in. Empty when ungrouped or the group-by did not resolve. */
-  groupValue: string;
+  /**
+   * Exactly one entry per declared dimension, rendered and truncated precisely as the persisted
+   * point attribute would be -- the preview must never disagree with the stored series.
+   */
+  resolvedDimensions: { [key: string]: string };
+}
+
+export interface DryRunEmission_ResolvedDimensionsEntry {
+  key: string;
+  value: string;
 }
 
 export interface DryRunNonEmission {
@@ -264,6 +372,48 @@ export interface DerivedMetricOutcomeCount {
   count: number;
 }
 
+export interface ListDerivedMetricAttributesRequest {
+  organizationId: string;
+  projectId: string;
+}
+
+export interface ListDerivedMetricAttributesResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** Trace-level attributes: usable as dimensions, population filters, or trace-attribute operands. */
+  traceAttributes: DerivedMetricAttribute[];
+  /** Events observed on recent traces, each with the attribute keys seen on that event name. */
+  events: DerivedMetricEventAttributes[];
+  /**
+   * Finished traces the walk covered (oversized/unreadable histories count -- permanent skips are
+   * not truncation). traces_sampled < traces_selected means the request budget expired mid-walk and
+   * the catalog is a truncated sample a retry can improve on, same contract as the dry run.
+   */
+  tracesSampled: number;
+  /** Finished traces the walk selected; zero means the project has no history yet. */
+  tracesSelected: number;
+  /**
+   * True when an output cap (distinct event names or total keys) dropped entries -- the catalog is
+   * complete for what it lists, but more keys exist than fit in one response.
+   */
+  catalogCapped: boolean;
+}
+
+export interface DerivedMetricAttribute {
+  key: string;
+  /** The stored type, from the typed attribute payloads -- not inferred from rendered strings. */
+  type: DerivedMetricAttributeType;
+  /** A few observed values, rendered canonically. Never exhaustive. */
+  sampleValues: string[];
+}
+
+export interface DerivedMetricEventAttributes {
+  /** The event's author-facing name; only info/warn/error events carry one. */
+  name: string;
+  attributes: DerivedMetricAttribute[];
+}
+
 function createBaseDerivedMetric(): DerivedMetric {
   return {
     id: "",
@@ -278,6 +428,7 @@ function createBaseDerivedMetric(): DerivedMetric {
     program: undefined,
     createdAt: undefined,
     updatedAt: undefined,
+    source: 0,
   };
 }
 
@@ -319,6 +470,9 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
     if (message.updatedAt !== undefined) {
       Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(98).fork()).join();
     }
+    if (message.source !== 0) {
+      writer.uint32(104).int32(message.source);
+    }
     return writer;
   },
 
@@ -425,6 +579,14 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
           message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
+        case 13: {
+          if (tag !== 104) {
+            break;
+          }
+
+          message.source = reader.int32() as any;
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -472,6 +634,7 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
         : isSet(object.updated_at)
         ? fromJsonTimestamp(object.updated_at)
         : undefined,
+      source: isSet(object.source) ? derivedMetricSourceFromJSON(object.source) : 0,
     };
   },
 
@@ -513,6 +676,9 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
     if (message.updatedAt !== undefined) {
       obj.updatedAt = message.updatedAt.toISOString();
     }
+    if (message.source !== 0) {
+      obj.source = derivedMetricSourceToJSON(message.source);
+    }
     return obj;
   },
 
@@ -535,12 +701,13 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
       : undefined;
     message.createdAt = object.createdAt ?? undefined;
     message.updatedAt = object.updatedAt ?? undefined;
+    message.source = object.source ?? 0;
     return message;
   },
 };
 
 function createBaseDerivedMetricProgram(): DerivedMetricProgram {
-  return { populationExpression: "", valueExpression: "", groupByExpression: "" };
+  return { populationExpression: "", valueExpression: "", dimensions: [] };
 }
 
 export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
@@ -551,8 +718,8 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
     if (message.valueExpression !== "") {
       writer.uint32(18).string(message.valueExpression);
     }
-    if (message.groupByExpression !== "") {
-      writer.uint32(26).string(message.groupByExpression);
+    for (const v of message.dimensions) {
+      writer.uint32(34).string(v!);
     }
     return writer;
   },
@@ -580,12 +747,12 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
           message.valueExpression = reader.string();
           continue;
         }
-        case 3: {
-          if (tag !== 26) {
+        case 4: {
+          if (tag !== 34) {
             break;
           }
 
-          message.groupByExpression = reader.string();
+          message.dimensions.push(reader.string());
           continue;
         }
       }
@@ -609,11 +776,9 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
         : isSet(object.value_expression)
         ? globalThis.String(object.value_expression)
         : "",
-      groupByExpression: isSet(object.groupByExpression)
-        ? globalThis.String(object.groupByExpression)
-        : isSet(object.group_by_expression)
-        ? globalThis.String(object.group_by_expression)
-        : "",
+      dimensions: globalThis.Array.isArray(object?.dimensions)
+        ? object.dimensions.map((e: any) => globalThis.String(e))
+        : [],
     };
   },
 
@@ -625,8 +790,8 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
     if (message.valueExpression !== "") {
       obj.valueExpression = message.valueExpression;
     }
-    if (message.groupByExpression !== "") {
-      obj.groupByExpression = message.groupByExpression;
+    if (message.dimensions?.length) {
+      obj.dimensions = message.dimensions;
     }
     return obj;
   },
@@ -638,7 +803,7 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
     const message = createBaseDerivedMetricProgram();
     message.populationExpression = object.populationExpression ?? "";
     message.valueExpression = object.valueExpression ?? "";
-    message.groupByExpression = object.groupByExpression ?? "";
+    message.dimensions = object.dimensions?.map((e) => e) || [];
     return message;
   },
 };
@@ -653,6 +818,7 @@ function createBaseCreateDerivedMetricRequest(): CreateDerivedMetricRequest {
     enabled: false,
     unit: "",
     program: undefined,
+    source: 0,
   };
 }
 
@@ -682,6 +848,9 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
     if (message.program !== undefined) {
       DerivedMetricProgram.encode(message.program, writer.uint32(66).fork()).join();
     }
+    if (message.source !== 0) {
+      writer.uint32(72).int32(message.source);
+    }
     return writer;
   },
 
@@ -756,6 +925,14 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
           message.program = DerivedMetricProgram.decode(reader, reader.uint32());
           continue;
         }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+
+          message.source = reader.int32() as any;
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -787,6 +964,7 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
       enabled: isSet(object.enabled) ? globalThis.Boolean(object.enabled) : false,
       unit: isSet(object.unit) ? globalThis.String(object.unit) : "",
       program: isSet(object.program) ? DerivedMetricProgram.fromJSON(object.program) : undefined,
+      source: isSet(object.source) ? derivedMetricSourceFromJSON(object.source) : 0,
     };
   },
 
@@ -816,6 +994,9 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
     if (message.program !== undefined) {
       obj.program = DerivedMetricProgram.toJSON(message.program);
     }
+    if (message.source !== 0) {
+      obj.source = derivedMetricSourceToJSON(message.source);
+    }
     return obj;
   },
 
@@ -834,6 +1015,7 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
     message.program = (object.program !== undefined && object.program !== null)
       ? DerivedMetricProgram.fromPartial(object.program)
       : undefined;
+    message.source = object.source ?? 0;
     return message;
   },
 };
@@ -2102,7 +2284,7 @@ export const DryRunTraceResult: MessageFns<DryRunTraceResult> = {
 };
 
 function createBaseDryRunEmission(): DryRunEmission {
-  return { value: 0, groupValue: "" };
+  return { value: 0, resolvedDimensions: {} };
 }
 
 export const DryRunEmission: MessageFns<DryRunEmission> = {
@@ -2110,9 +2292,9 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
     if (message.value !== 0) {
       writer.uint32(9).double(message.value);
     }
-    if (message.groupValue !== "") {
-      writer.uint32(18).string(message.groupValue);
-    }
+    globalThis.Object.entries(message.resolvedDimensions).forEach(([key, value]: [string, string]) => {
+      DryRunEmission_ResolvedDimensionsEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).join();
+    });
     return writer;
   },
 
@@ -2131,12 +2313,15 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
           message.value = reader.double();
           continue;
         }
-        case 2: {
-          if (tag !== 18) {
+        case 3: {
+          if (tag !== 26) {
             break;
           }
 
-          message.groupValue = reader.string();
+          const entry3 = DryRunEmission_ResolvedDimensionsEntry.decode(reader, reader.uint32());
+          if (entry3.value !== undefined) {
+            message.resolvedDimensions[entry3.key] = entry3.value;
+          }
           continue;
         }
       }
@@ -2151,11 +2336,23 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
   fromJSON(object: any): DryRunEmission {
     return {
       value: isSet(object.value) ? globalThis.Number(object.value) : 0,
-      groupValue: isSet(object.groupValue)
-        ? globalThis.String(object.groupValue)
-        : isSet(object.group_value)
-        ? globalThis.String(object.group_value)
-        : "",
+      resolvedDimensions: isObject(object.resolvedDimensions)
+        ? (globalThis.Object.entries(object.resolvedDimensions) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : isObject(object.resolved_dimensions)
+        ? (globalThis.Object.entries(object.resolved_dimensions) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
     };
   },
 
@@ -2164,8 +2361,14 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
     if (message.value !== 0) {
       obj.value = message.value;
     }
-    if (message.groupValue !== "") {
-      obj.groupValue = message.groupValue;
+    if (message.resolvedDimensions) {
+      const entries = globalThis.Object.entries(message.resolvedDimensions) as [string, string][];
+      if (entries.length > 0) {
+        obj.resolvedDimensions = {};
+        entries.forEach(([k, v]) => {
+          obj.resolvedDimensions[k] = v;
+        });
+      }
     }
     return obj;
   },
@@ -2176,7 +2379,93 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
   fromPartial<I extends Exact<DeepPartial<DryRunEmission>, I>>(object: I): DryRunEmission {
     const message = createBaseDryRunEmission();
     message.value = object.value ?? 0;
-    message.groupValue = object.groupValue ?? "";
+    message.resolvedDimensions = (globalThis.Object.entries(object.resolvedDimensions ?? {}) as [string, string][])
+      .reduce((acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      }, {});
+    return message;
+  },
+};
+
+function createBaseDryRunEmission_ResolvedDimensionsEntry(): DryRunEmission_ResolvedDimensionsEntry {
+  return { key: "", value: "" };
+}
+
+export const DryRunEmission_ResolvedDimensionsEntry: MessageFns<DryRunEmission_ResolvedDimensionsEntry> = {
+  encode(message: DryRunEmission_ResolvedDimensionsEntry, 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): DryRunEmission_ResolvedDimensionsEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDryRunEmission_ResolvedDimensionsEntry();
+    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): DryRunEmission_ResolvedDimensionsEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: DryRunEmission_ResolvedDimensionsEntry): 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<DryRunEmission_ResolvedDimensionsEntry>, I>>(
+    base?: I,
+  ): DryRunEmission_ResolvedDimensionsEntry {
+    return DryRunEmission_ResolvedDimensionsEntry.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DryRunEmission_ResolvedDimensionsEntry>, I>>(
+    object: I,
+  ): DryRunEmission_ResolvedDimensionsEntry {
+    const message = createBaseDryRunEmission_ResolvedDimensionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     return message;
   },
 };
@@ -2333,6 +2622,439 @@ export const DerivedMetricOutcomeCount: MessageFns<DerivedMetricOutcomeCount> =
   },
 };
 
+function createBaseListDerivedMetricAttributesRequest(): ListDerivedMetricAttributesRequest {
+  return { organizationId: "", projectId: "" };
+}
+
+export const ListDerivedMetricAttributesRequest: MessageFns<ListDerivedMetricAttributesRequest> = {
+  encode(message: ListDerivedMetricAttributesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListDerivedMetricAttributesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListDerivedMetricAttributesRequest();
+    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;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListDerivedMetricAttributesRequest {
+    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)
+        : "",
+    };
+  },
+
+  toJSON(message: ListDerivedMetricAttributesRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListDerivedMetricAttributesRequest>, I>>(
+    base?: I,
+  ): ListDerivedMetricAttributesRequest {
+    return ListDerivedMetricAttributesRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListDerivedMetricAttributesRequest>, I>>(
+    object: I,
+  ): ListDerivedMetricAttributesRequest {
+    const message = createBaseListDerivedMetricAttributesRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    return message;
+  },
+};
+
+function createBaseListDerivedMetricAttributesResponse(): ListDerivedMetricAttributesResponse {
+  return {
+    status: undefined,
+    traceAttributes: [],
+    events: [],
+    tracesSampled: 0,
+    tracesSelected: 0,
+    catalogCapped: false,
+  };
+}
+
+export const ListDerivedMetricAttributesResponse: MessageFns<ListDerivedMetricAttributesResponse> = {
+  encode(message: ListDerivedMetricAttributesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.traceAttributes) {
+      DerivedMetricAttribute.encode(v!, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.events) {
+      DerivedMetricEventAttributes.encode(v!, writer.uint32(26).fork()).join();
+    }
+    if (message.tracesSampled !== 0) {
+      writer.uint32(32).uint32(message.tracesSampled);
+    }
+    if (message.tracesSelected !== 0) {
+      writer.uint32(40).uint32(message.tracesSelected);
+    }
+    if (message.catalogCapped !== false) {
+      writer.uint32(48).bool(message.catalogCapped);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListDerivedMetricAttributesResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListDerivedMetricAttributesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.traceAttributes.push(DerivedMetricAttribute.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.events.push(DerivedMetricEventAttributes.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.tracesSampled = reader.uint32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.tracesSelected = reader.uint32();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.catalogCapped = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListDerivedMetricAttributesResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      traceAttributes: globalThis.Array.isArray(object?.traceAttributes)
+        ? object.traceAttributes.map((e: any) => DerivedMetricAttribute.fromJSON(e))
+        : globalThis.Array.isArray(object?.trace_attributes)
+        ? object.trace_attributes.map((e: any) => DerivedMetricAttribute.fromJSON(e))
+        : [],
+      events: globalThis.Array.isArray(object?.events)
+        ? object.events.map((e: any) => DerivedMetricEventAttributes.fromJSON(e))
+        : [],
+      tracesSampled: isSet(object.tracesSampled)
+        ? globalThis.Number(object.tracesSampled)
+        : isSet(object.traces_sampled)
+        ? globalThis.Number(object.traces_sampled)
+        : 0,
+      tracesSelected: isSet(object.tracesSelected)
+        ? globalThis.Number(object.tracesSelected)
+        : isSet(object.traces_selected)
+        ? globalThis.Number(object.traces_selected)
+        : 0,
+      catalogCapped: isSet(object.catalogCapped)
+        ? globalThis.Boolean(object.catalogCapped)
+        : isSet(object.catalog_capped)
+        ? globalThis.Boolean(object.catalog_capped)
+        : false,
+    };
+  },
+
+  toJSON(message: ListDerivedMetricAttributesResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.traceAttributes?.length) {
+      obj.traceAttributes = message.traceAttributes.map((e) => DerivedMetricAttribute.toJSON(e));
+    }
+    if (message.events?.length) {
+      obj.events = message.events.map((e) => DerivedMetricEventAttributes.toJSON(e));
+    }
+    if (message.tracesSampled !== 0) {
+      obj.tracesSampled = Math.round(message.tracesSampled);
+    }
+    if (message.tracesSelected !== 0) {
+      obj.tracesSelected = Math.round(message.tracesSelected);
+    }
+    if (message.catalogCapped !== false) {
+      obj.catalogCapped = message.catalogCapped;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListDerivedMetricAttributesResponse>, I>>(
+    base?: I,
+  ): ListDerivedMetricAttributesResponse {
+    return ListDerivedMetricAttributesResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListDerivedMetricAttributesResponse>, I>>(
+    object: I,
+  ): ListDerivedMetricAttributesResponse {
+    const message = createBaseListDerivedMetricAttributesResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.traceAttributes = object.traceAttributes?.map((e) => DerivedMetricAttribute.fromPartial(e)) || [];
+    message.events = object.events?.map((e) => DerivedMetricEventAttributes.fromPartial(e)) || [];
+    message.tracesSampled = object.tracesSampled ?? 0;
+    message.tracesSelected = object.tracesSelected ?? 0;
+    message.catalogCapped = object.catalogCapped ?? false;
+    return message;
+  },
+};
+
+function createBaseDerivedMetricAttribute(): DerivedMetricAttribute {
+  return { key: "", type: 0, sampleValues: [] };
+}
+
+export const DerivedMetricAttribute: MessageFns<DerivedMetricAttribute> = {
+  encode(message: DerivedMetricAttribute, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.type !== 0) {
+      writer.uint32(16).int32(message.type);
+    }
+    for (const v of message.sampleValues) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DerivedMetricAttribute {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDerivedMetricAttribute();
+    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 !== 16) {
+            break;
+          }
+
+          message.type = reader.int32() as any;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.sampleValues.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DerivedMetricAttribute {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      type: isSet(object.type) ? derivedMetricAttributeTypeFromJSON(object.type) : 0,
+      sampleValues: globalThis.Array.isArray(object?.sampleValues)
+        ? object.sampleValues.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.sample_values)
+        ? object.sample_values.map((e: any) => globalThis.String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: DerivedMetricAttribute): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.type !== 0) {
+      obj.type = derivedMetricAttributeTypeToJSON(message.type);
+    }
+    if (message.sampleValues?.length) {
+      obj.sampleValues = message.sampleValues;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DerivedMetricAttribute>, I>>(base?: I): DerivedMetricAttribute {
+    return DerivedMetricAttribute.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DerivedMetricAttribute>, I>>(object: I): DerivedMetricAttribute {
+    const message = createBaseDerivedMetricAttribute();
+    message.key = object.key ?? "";
+    message.type = object.type ?? 0;
+    message.sampleValues = object.sampleValues?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseDerivedMetricEventAttributes(): DerivedMetricEventAttributes {
+  return { name: "", attributes: [] };
+}
+
+export const DerivedMetricEventAttributes: MessageFns<DerivedMetricEventAttributes> = {
+  encode(message: DerivedMetricEventAttributes, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    for (const v of message.attributes) {
+      DerivedMetricAttribute.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DerivedMetricEventAttributes {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDerivedMetricEventAttributes();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.attributes.push(DerivedMetricAttribute.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DerivedMetricEventAttributes {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      attributes: globalThis.Array.isArray(object?.attributes)
+        ? object.attributes.map((e: any) => DerivedMetricAttribute.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: DerivedMetricEventAttributes): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.attributes?.length) {
+      obj.attributes = message.attributes.map((e) => DerivedMetricAttribute.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DerivedMetricEventAttributes>, I>>(base?: I): DerivedMetricEventAttributes {
+    return DerivedMetricEventAttributes.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DerivedMetricEventAttributes>, I>>(object: I): DerivedMetricEventAttributes {
+    const message = createBaseDerivedMetricEventAttributes();
+    message.name = object.name ?? "";
+    message.attributes = object.attributes?.map((e) => DerivedMetricAttribute.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 /**
  * DerivedMetricGatewayService provides web client access to derived metrics: definitions that turn
  * each finished trace into one gauge datapoint. The resulting series is queried through
@@ -2346,6 +3068,14 @@ export interface DerivedMetricGatewayService {
   DeleteDerivedMetric(request: DeleteDerivedMetricRequest, metadata?: Metadata): Promise<DeleteDerivedMetricResponse>;
   /** Evaluates an unsaved program against recent finished traces; persists nothing. */
   DryRunDerivedMetric(request: DryRunDerivedMetricRequest, metadata?: Metadata): Promise<DryRunDerivedMetricResponse>;
+  /**
+   * The authoring catalog: attribute keys, types and sample values observed on recent finished
+   * traces -- trace-level and per-event -- so a builder offers real keys instead of free text.
+   */
+  ListDerivedMetricAttributes(
+    request: ListDerivedMetricAttributesRequest,
+    metadata?: Metadata,
+  ): Promise<ListDerivedMetricAttributesResponse>;
 }
 
 export const DerivedMetricGatewayServiceServiceName = "gateway.web.v1.DerivedMetricGatewayService";
@@ -2361,6 +3091,7 @@ export class DerivedMetricGatewayServiceClientImpl implements DerivedMetricGatew
     this.UpdateDerivedMetric = this.UpdateDerivedMetric.bind(this);
     this.DeleteDerivedMetric = this.DeleteDerivedMetric.bind(this);
     this.DryRunDerivedMetric = this.DryRunDerivedMetric.bind(this);
+    this.ListDerivedMetricAttributes = this.ListDerivedMetricAttributes.bind(this);
   }
   CreateDerivedMetric(request: CreateDerivedMetricRequest, metadata?: Metadata): Promise<CreateDerivedMetricResponse> {
     const data = CreateDerivedMetricRequest.encode(request).finish();
@@ -2397,6 +3128,15 @@ export class DerivedMetricGatewayServiceClientImpl implements DerivedMetricGatew
     const promise = this.rpc.request(this.service, "DryRunDerivedMetric", data, metadata);
     return promise.then((data) => DryRunDerivedMetricResponse.decode(new BinaryReader(data)));
   }
+
+  ListDerivedMetricAttributes(
+    request: ListDerivedMetricAttributesRequest,
+    metadata?: Metadata,
+  ): Promise<ListDerivedMetricAttributesResponse> {
+    const data = ListDerivedMetricAttributesRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ListDerivedMetricAttributes", data, metadata);
+    return promise.then((data) => ListDerivedMetricAttributesResponse.decode(new BinaryReader(data)));
+  }
 }
 
 interface Rpc {
@@ -2437,6 +3177,10 @@ function fromJsonTimestamp(o: any): Date {
   }
 }
 
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }