@causa/workspace-google 1.4.0-beta.1 → 1.4.0-beta.3

package/dist/graph/environment/monitoring-query.d.ts

@@ -0,0 +1,116 @@
+import { type GraphBucketLayoutsByName, type GraphEnvironmentNodeOutput, type GraphMetricValue, type GraphWarning } from '@causa/workspace-core';
+import { type GraphEnvironmentContext } from '@causa/workspace-core/graph';
+import { type MonitoringMetric } from './monitoring-catalog.js';
+import { BucketLayoutRegistry } from './monitoring-values.js';
+/**
+ * The minimum alignment period accepted by Cloud Monitoring, in seconds.
+ */
+export declare const MIN_ALIGNMENT_PERIOD = 60;
+/**
+ * The delay after which Cloud Monitoring is expected to expose complete data, in seconds.
+ * Periods ending more recently may miss points, e.g. making rates look like 0.
+ */
+export declare const MONITORING_DATA_DELAY = 300;
+/**
+ * Returns the end of the periods over which metrics are read, which is at most {@link MONITORING_DATA_DELAY} before
+ * now.
+ *
+ * @param end The requested end.
+ * @returns The requested end, or {@link MONITORING_DATA_DELAY} before now if it is more recent.
+ */
+export declare function monitoringEnd(end: Date): Date;
+/**
+ * The value of a metric of a node over one period, and the values of its groups when the metric is grouped.
+ */
+export type MonitoringPoint = Pick<GraphMetricValue, 'value' | 'groups'>;
+/**
+ * The consecutive periods over which {@link queryMonitoringMetric} reads a metric.
+ */
+export type MonitoringPeriods = {
+    /**
+     * The end of the last period.
+     */
+    readonly end: Date;
+    /**
+     * The length of each period, in seconds. It is at least {@link MIN_ALIGNMENT_PERIOD}.
+     */
+    readonly period: number;
+    /**
+     * The number of periods, ending at {@link MonitoringPeriods.end}.
+     */
+    readonly count: number;
+};
+/**
+ * The result of {@link queryMonitoringMetric}.
+ */
+export type MonitoringQueryResult = {
+    /**
+     * The values for each period, keyed by node ID. A period without data is `undefined`.
+     */
+    readonly values: Map<string, (MonitoringPoint | undefined)[]>;
+    /**
+     * The names of the group keys of the values, when they are grouped.
+     */
+    readonly groupBy?: string[];
+    /**
+     * The time series that could not be read, e.g. in a project. The values of the nodes they measure are missing.
+     */
+    readonly errors: GraphWarning[];
+    /**
+     * Things worth reporting that don't affect the values, e.g. time series relating to resources missing from the graph.
+     */
+    readonly warnings: GraphWarning[];
+};
+/**
+ * Optional restrictions on the values returned by {@link queryMonitoringMetric}.
+ */
+export type MonitoringQueryOptions = {
+    /**
+     * The IDs of the nodes for which values should be returned. Defaults to all the nodes measured by the metric.
+     */
+    readonly nodes?: readonly string[];
+};
+/**
+ * Reads the values of a metric over consecutive periods from Cloud Monitoring, for the nodes of the graph it measures.
+ * Time series are aligned over each period, and combined across the series of a node and group, within Cloud
+ * Monitoring. Time series are read once per GCP project, and only those of the project are kept.
+ * Metrics with {@link MonitoringMetric.groupByNode} mappings are also grouped by the nodes their time series relate to,
+ * unless one of the mappings could not be prepared. Time series relating to resources that are not in the graph are
+ * reported as warnings.
+ *
+ * @param environment The context of the environment, from which the Cloud Monitoring client and the resources of the
+ *   graph are obtained.
+ * @param metric The metric to read.
+ * @param periods The periods over which the metric is read.
+ * @param layouts The registry naming the bucket layouts of distributions.
+ * @param options Restrictions on the nodes for which values are returned.
+ * @returns The values for each node and period.
+ */
+export declare function queryMonitoringMetric(environment: GraphEnvironmentContext, metric: MonitoringMetric, periods: MonitoringPeriods, layouts: BucketLayoutRegistry, options?: MonitoringQueryOptions): Promise<MonitoringQueryResult>;
+/**
+ * The result of {@link queryPointInTimeMetrics}.
+ */
+export type PointInTimeMetrics = {
+    /**
+     * The values of the metrics, keyed by node ID.
+     */
+    readonly nodes: Record<string, GraphEnvironmentNodeOutput>;
+    /**
+     * The bucket layouts referenced by the distributions.
+     */
+    readonly bucketLayouts: GraphBucketLayoutsByName;
+    /**
+     * The warnings raised while reading the time series, or resolving the nodes of groups.
+     */
+    readonly warnings: GraphWarning[];
+};
+/**
+ * Reads the values of metrics over the evaluation window of an enrichment, for all the nodes of the graph, using
+ * {@link queryMonitoringMetric}.
+ * The window ends at most {@link MONITORING_DATA_DELAY} before now, such that it only covers complete data.
+ *
+ * @param environment The context of the enrichment.
+ * @param metrics The metrics to read.
+ * @returns The values of the metrics for each node.
+ */
+export declare function queryPointInTimeMetrics(environment: GraphEnvironmentContext, metrics: readonly MonitoringMetric[]): Promise<PointInTimeMetrics>;

package/dist/graph/environment/monitoring-query.js

@@ -0,0 +1,314 @@
+import { GraphMetricKind, } from '@causa/workspace-core';
+import { sumGraphMetricMeasures, } from '@causa/workspace-core/graph';
+import { monitoringMetricKind, } from './monitoring-catalog.js';
+import { findMonitoredNode, monitoringLabelName, prepareMonitoringMapping, readMonitoringResourceKey, } from './monitoring-mappings.js';
+import { BucketLayoutRegistry, toMeasure, toNumber, } from './monitoring-values.js';
+import { googleResources } from './resources.js';
+/**
+ * The gRPC code returned when a metric does not exist, e.g. because no data was ever written for it.
+ */
+const NOT_FOUND_CODE = 5;
+/**
+ * How time series are aligned over a period, for each kind of metric.
+ * `ALIGN_RATE` returns a rate per second, `ALIGN_DELTA` the merged distribution over the period, and
+ * `ALIGN_NEXT_OLDER` the latest point before the end of the period.
+ */
+const ALIGNERS = {
+    [GraphMetricKind.Rate]: 'ALIGN_RATE',
+    [GraphMetricKind.Distribution]: 'ALIGN_DELTA',
+    [GraphMetricKind.Gauge]: 'ALIGN_NEXT_OLDER',
+};
+/**
+ * The minimum alignment period accepted by Cloud Monitoring, in seconds.
+ */
+export const MIN_ALIGNMENT_PERIOD = 60;
+/**
+ * The delay after which Cloud Monitoring is expected to expose complete data, in seconds.
+ * Periods ending more recently may miss points, e.g. making rates look like 0.
+ */
+export const MONITORING_DATA_DELAY = 300;
+/**
+ * Returns the end of the periods over which metrics are read, which is at most {@link MONITORING_DATA_DELAY} before
+ * now.
+ *
+ * @param end The requested end.
+ * @returns The requested end, or {@link MONITORING_DATA_DELAY} before now if it is more recent.
+ */
+export function monitoringEnd(end) {
+    return new Date(Math.min(end.getTime(), Date.now() - MONITORING_DATA_DELAY * 1000));
+}
+/**
+ * The group key whose values are the IDs of the nodes resolved from the {@link MonitoringMetric.groupByNode} mappings.
+ */
+const NODE_GROUP_KEY = 'node';
+/**
+ * Returns the value of a label of a time series.
+ *
+ * @param series The time series.
+ * @param label The label, e.g. `resource.label.service_name` or `metric.label.response_code`.
+ * @returns The value of the label.
+ */
+function labelValue(series, label) {
+    const labels = label.startsWith('resource.')
+        ? series.resource?.labels
+        : series.metric?.labels;
+    return labels?.[monitoringLabelName(label)] ?? undefined;
+}
+/**
+ * Combines several measures of the same node and group.
+ */
+function combine(measures, reducer) {
+    if (reducer === 'REDUCE_MAX' &&
+        measures.every((m) => typeof m === 'number')) {
+        return Math.max(...measures);
+    }
+    return sumGraphMetricMeasures(measures);
+}
+/**
+ * Returns whether a measure is empty, i.e. 0 or a distribution without values.
+ */
+function isEmpty(measure) {
+    return typeof measure === 'number' ? measure === 0 : measure.count === 0;
+}
+/**
+ * Builds the point of a period from the measures of its groups.
+ * For rates and distributions, empty groups are dropped.
+ *
+ * @param byGroup The measures of the period, keyed by serialized group key.
+ * @param metric The metric.
+ * @param kind The kind of the values of the metric.
+ * @param grouped Whether the values of the metric are grouped.
+ * @returns The point, or `undefined` if all its groups are empty.
+ */
+function toPoint(byGroup, metric, kind, grouped) {
+    const reducer = metric.reducer ?? 'REDUCE_SUM';
+    const groups = [...byGroup.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([, { key, measures }]) => ({
+        key,
+        value: combine(measures, reducer),
+    }))
+        .filter((g) => kind === GraphMetricKind.Gauge || !isEmpty(g.value));
+    if (groups.length === 0) {
+        return undefined;
+    }
+    const value = combine(groups.map((g) => g.value), reducer);
+    return grouped ? { value, groups } : { value };
+}
+/**
+ * Reads the values of a metric over consecutive periods from Cloud Monitoring, for the nodes of the graph it measures.
+ * Time series are aligned over each period, and combined across the series of a node and group, within Cloud
+ * Monitoring. Time series are read once per GCP project, and only those of the project are kept.
+ * Metrics with {@link MonitoringMetric.groupByNode} mappings are also grouped by the nodes their time series relate to,
+ * unless one of the mappings could not be prepared. Time series relating to resources that are not in the graph are
+ * reported as warnings.
+ *
+ * @param environment The context of the environment, from which the Cloud Monitoring client and the resources of the
+ *   graph are obtained.
+ * @param metric The metric to read.
+ * @param periods The periods over which the metric is read.
+ * @param layouts The registry naming the bucket layouts of distributions.
+ * @param options Restrictions on the nodes for which values are returned.
+ * @returns The values for each node and period.
+ */
+export async function queryMonitoringMetric(environment, metric, periods, layouts, options = {}) {
+    const { CloudMonitoringService } = await import('../../services/cloud-monitoring.js');
+    const { client } = environment.context.service(CloudMonitoringService);
+    // Calls on a gax client crash the process when credentials cannot be loaded, while `initialize` rejects.
+    await client.initialize();
+    const { mapping } = metric;
+    const { end, count } = periods;
+    const period = Math.max(Math.round(periods.period), MIN_ALIGNMENT_PERIOD);
+    const kind = monitoringMetricKind(metric);
+    const errors = [];
+    const nodes = options.nodes && new Set(options.nodes);
+    const measured = new Map(googleResources(environment, mapping.resourceType, mapping.nodeType)
+        .filter((r) => (!nodes || nodes.has(r.node.id)) &&
+        (!metric.measures || metric.measures(r.node, environment.graph)))
+        .map((r) => [r.name, r]));
+    // A mapping that could not be prepared is reported as a failure of the fact it depends on.
+    const primary = await prepareMonitoringMapping(environment, mapping);
+    if (!primary) {
+        return { values: new Map(), errors, warnings: [] };
+    }
+    // Values are only grouped by node when all the mappings are prepared. Otherwise, a group without node could either
+    // relate to a resource missing from the graph, or to one of a mapping that could not be prepared.
+    const nodeMappings = metric.groupByNode ?? [];
+    const preparedNodeMappings = await Promise.all(nodeMappings.map((m) => prepareMonitoringMapping(environment, m)));
+    const groupsByNode = nodeMappings.length > 0 && preparedNodeMappings.every((m) => !!m);
+    const nodeResolvers = groupsByNode
+        ? preparedNodeMappings
+        : [];
+    // Time series relating to resources that are not in the graph are worth reporting, unlike the time series of other
+    // resources of the metric, which are expected.
+    const unmapped = new Set();
+    const groupByEntries = Object.entries(metric.groupBy ?? {});
+    const groupBy = [
+        ...groupByEntries.map(([name]) => name),
+        ...(groupsByNode ? [NODE_GROUP_KEY] : []),
+    ];
+    const grouped = groupBy.length > 0;
+    const endSeconds = Math.floor(end.getTime() / 1000);
+    const request = {
+        interval: {
+            startTime: { seconds: endSeconds - count * period },
+            endTime: { seconds: endSeconds },
+        },
+        aggregation: {
+            alignmentPeriod: { seconds: period },
+            perSeriesAligner: metric.countRate ? 'ALIGN_DELTA' : ALIGNERS[kind],
+            crossSeriesReducer: metric.reducer ?? 'REDUCE_SUM',
+            groupByFields: [
+                ...new Set([
+                    ...mapping.keyLabels,
+                    ...groupByEntries.map(([, label]) => label),
+                    ...nodeResolvers.flatMap(({ mapping }) => mapping.keyLabels),
+                ]),
+            ],
+        },
+        view: 'FULL',
+    };
+    const accumulated = new Map();
+    const succeededProjects = new Set();
+    const projects = new Set([...measured.values()].map((r) => r.segments.projects));
+    for (const project of projects) {
+        let series;
+        try {
+            [series] = await client.listTimeSeries({
+                ...request,
+                name: `projects/${project}`,
+                // A project may be the scoping project of a metrics scope, whose time series include other projects'.
+                filter: [
+                    `metric.type = "${metric.metricType}"`,
+                    `resource.type = "${mapping.monitoredResource}"`,
+                    `project = "${project}"`,
+                    ...(metric.filter ? [metric.filter] : []),
+                ].join(' AND '),
+            });
+        }
+        catch (error) {
+            if (error.code === NOT_FOUND_CODE) {
+                succeededProjects.add(project);
+            }
+            else {
+                errors.push({
+                    message: `Failed to read the metric '${metric.metricType}' in project '${project}': ${error.message ?? error}`,
+                });
+            }
+            continue;
+        }
+        succeededProjects.add(project);
+        for (const timeSeries of series) {
+            const read = (label) => labelValue(timeSeries, label);
+            const key = readMonitoringResourceKey(mapping, project, read);
+            const name = key && primary.resolve(key);
+            const node = name && measured.get(name)?.node.id;
+            if (!node) {
+                continue;
+            }
+            const groupKey = {};
+            for (const [name, label] of groupByEntries) {
+                const value = labelValue(timeSeries, label);
+                if (value) {
+                    groupKey[name] = value;
+                }
+            }
+            if (groupsByNode) {
+                const { node: groupNode, missing } = findMonitoredNode(environment, nodeResolvers, project, read);
+                if (groupNode) {
+                    groupKey[NODE_GROUP_KEY] = groupNode.id;
+                }
+                else {
+                    missing.forEach(({ mapping, key, name }) => {
+                        const description = Object.entries(key.labels)
+                            .map(([label, value]) => `${label}=${value}`)
+                            .sort()
+                            .join(', ');
+                        unmapped.add(`The '${mapping.monitoredResource}' time series with ${description} relate to '${name}', which is not in the graph.`);
+                    });
+                }
+            }
+            const serializedGroupKey = JSON.stringify(groupKey);
+            for (const point of timeSeries.points ?? []) {
+                const pointEnd = toNumber(point.interval?.endTime?.seconds);
+                const index = count - 1 - Math.round((endSeconds - pointEnd) / period);
+                if (index < 0 || index >= count || !point.value) {
+                    continue;
+                }
+                const byIndex = accumulated.get(node) ?? new Map();
+                accumulated.set(node, byIndex);
+                const byGroup = byIndex.get(index) ?? new Map();
+                byIndex.set(index, byGroup);
+                const group = byGroup.get(serializedGroupKey) ?? {
+                    key: groupKey,
+                    measures: [],
+                };
+                byGroup.set(serializedGroupKey, group);
+                group.measures.push(toMeasure(point.value, metric, period, layouts));
+            }
+        }
+    }
+    // Rates are 0 when nothing happened during a period, in which case Cloud Monitoring returns no point, or only empty
+    // ones. Gauges and distributions without points are left missing, as there may simply be no sample during the period.
+    const zero = kind !== GraphMetricKind.Rate
+        ? undefined
+        : grouped
+            ? { value: 0, groups: [] }
+            : { value: 0 };
+    const values = new Map();
+    for (const { node, segments } of measured.values()) {
+        const byIndex = accumulated.get(node.id);
+        const succeeded = succeededProjects.has(segments.projects);
+        if (!byIndex && (!zero || !succeeded)) {
+            continue;
+        }
+        const points = Array.from({ length: count }, (_, index) => {
+            const byGroup = byIndex?.get(index);
+            const point = byGroup && toPoint(byGroup, metric, kind, grouped);
+            return point ?? (succeeded ? zero : undefined);
+        });
+        values.set(node.id, points);
+    }
+    const warnings = [...unmapped].sort().map((message) => ({ message }));
+    return { values, ...(grouped ? { groupBy } : {}), errors, warnings };
+}
+/**
+ * Reads the values of metrics over the evaluation window of an enrichment, for all the nodes of the graph, using
+ * {@link queryMonitoringMetric}.
+ * The window ends at most {@link MONITORING_DATA_DELAY} before now, such that it only covers complete data.
+ *
+ * @param environment The context of the enrichment.
+ * @param metrics The metrics to read.
+ * @returns The values of the metrics for each node.
+ */
+export async function queryPointInTimeMetrics(environment, metrics) {
+    const layouts = new BucketLayoutRegistry();
+    const results = await Promise.all(metrics.map(async (metric) => ({
+        metric,
+        result: await queryMonitoringMetric(environment, metric, {
+            end: monitoringEnd(environment.at),
+            period: Math.max(environment.window, metric.minPeriod ?? 0),
+            count: 1,
+        }, layouts),
+    })));
+    const nodes = {};
+    for (const { metric, result } of results) {
+        for (const [node, [point]] of result.values) {
+            if (!point) {
+                continue;
+            }
+            const { value, groups } = point;
+            const { groupBy } = result;
+            nodes[node] ??= { metrics: {} };
+            nodes[node].metrics[metric.metric] =
+                groups && groupBy ? { value, groupBy, groups } : { value };
+        }
+    }
+    // Several metrics read from the same time series raise the same warnings, e.g. about resources not in the graph.
+    const messages = new Set(results.flatMap(({ result }) => [...result.errors, ...result.warnings].map((w) => w.message)));
+    return {
+        nodes,
+        bucketLayouts: layouts.all,
+        warnings: [...messages].map((message) => ({ message })),
+    };
+}

package/dist/graph/environment/monitoring-values.d.ts

@@ -0,0 +1,41 @@
+import type { GraphBucketLayoutsByName, GraphMetricMeasure } from '@causa/workspace-core';
+import type { protos } from '@google-cloud/monitoring';
+import type { MonitoringMetric } from './monitoring-catalog.js';
+type TypedValue = protos.google.monitoring.v3.ITypedValue;
+/**
+ * Names the bucket layouts of distributions, such that distributions with the same bounds share a layout.
+ */
+export declare class BucketLayoutRegistry {
+    /**
+     * The registered layouts, keyed by name.
+     */
+    private readonly layouts;
+    /**
+     * Returns the name of the layout with the given bounds, registering it if needed.
+     * Layouts are named after the metric type. Layouts of the same metric type with different bounds get a suffix.
+     *
+     * @param baseName The base name of the layout, e.g. the metric type.
+     * @param bounds The bounds of the layout.
+     * @returns The name of the layout.
+     */
+    register(baseName: string, bounds: number[]): string;
+    /**
+     * The registered layouts, keyed by name.
+     */
+    get all(): GraphBucketLayoutsByName;
+}
+/**
+ * Converts a protobuf number, which may be a string or a `Long` for 64-bit integers, to a number.
+ */
+export declare function toNumber(value: unknown): number;
+/**
+ * Converts the value of a point to a {@link GraphMetricMeasure}.
+ *
+ * @param value The value of the point.
+ * @param metric The metric.
+ * @param period The alignment period, in seconds.
+ * @param layouts The registry of layouts.
+ * @returns The measure.
+ */
+export declare function toMeasure(value: TypedValue, metric: MonitoringMetric, period: number, layouts: BucketLayoutRegistry): GraphMetricMeasure;
+export {};

package/dist/graph/environment/monitoring-values.js

@@ -0,0 +1,119 @@
+/**
+ * The number of significant digits to which the bounds of buckets are rounded.
+ * Computing bounds, e.g. `scale * growthFactor ** i`, leaves floating point noise in the last digits. Doubles guarantee
+ * 15 significant digits. This leaves a margin for accumulated errors, while keeping more precision than bounds need.
+ */
+const BOUND_SIGNIFICANT_DIGITS = 12;
+/**
+ * Names the bucket layouts of distributions, such that distributions with the same bounds share a layout.
+ */
+export class BucketLayoutRegistry {
+    /**
+     * The registered layouts, keyed by name.
+     */
+    layouts = {};
+    /**
+     * Returns the name of the layout with the given bounds, registering it if needed.
+     * Layouts are named after the metric type. Layouts of the same metric type with different bounds get a suffix.
+     *
+     * @param baseName The base name of the layout, e.g. the metric type.
+     * @param bounds The bounds of the layout.
+     * @returns The name of the layout.
+     */
+    register(baseName, bounds) {
+        const serialized = JSON.stringify(bounds);
+        for (let index = 1;; index++) {
+            const name = index === 1 ? baseName : `${baseName}#${index}`;
+            const existing = this.layouts[name];
+            if (!existing) {
+                this.layouts[name] = bounds;
+                return name;
+            }
+            if (JSON.stringify(existing) === serialized) {
+                return name;
+            }
+        }
+    }
+    /**
+     * The registered layouts, keyed by name.
+     */
+    get all() {
+        return { ...this.layouts };
+    }
+}
+/**
+ * Converts a protobuf number, which may be a string or a `Long` for 64-bit integers, to a number.
+ */
+export function toNumber(value) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    return typeof value === 'object' ? Number(value.toString()) : Number(value);
+}
+/**
+ * Returns the bounds of the buckets of a Cloud Monitoring distribution.
+ *
+ * @param distribution The distribution.
+ * @returns The bounds, or `undefined` if the bucket options are not supported.
+ */
+function distributionBounds(distribution) {
+    const { linearBuckets, exponentialBuckets, explicitBuckets } = distribution.bucketOptions ?? {};
+    if (linearBuckets) {
+        const { numFiniteBuckets, width, offset } = linearBuckets;
+        return Array.from({ length: (numFiniteBuckets ?? 0) + 1 }, (_, i) => (offset ?? 0) + (width ?? 0) * i);
+    }
+    if (exponentialBuckets) {
+        const { numFiniteBuckets, growthFactor, scale } = exponentialBuckets;
+        return Array.from({ length: (numFiniteBuckets ?? 0) + 1 }, (_, i) => (scale ?? 0) * (growthFactor ?? 0) ** i);
+    }
+    if (explicitBuckets?.bounds) {
+        return [...explicitBuckets.bounds];
+    }
+    return undefined;
+}
+/**
+ * Converts a Cloud Monitoring distribution to a {@link GraphDistribution}.
+ *
+ * @param distribution The distribution.
+ * @param scale The factor applied to the values.
+ * @param layoutBaseName The base name of the layout.
+ * @param layouts The registry of layouts.
+ * @returns The distribution.
+ */
+function toGraphDistribution(distribution, scale, layoutBaseName, layouts) {
+    const bounds = (distributionBounds(distribution) ?? []).map((b) => Number((b * scale).toPrecision(BOUND_SIGNIFICANT_DIGITS)));
+    const layout = layouts.register(layoutBaseName, bounds);
+    const count = toNumber(distribution.count);
+    const buckets = {};
+    (distribution.bucketCounts ?? []).forEach((bucketCount, index) => {
+        const value = toNumber(bucketCount);
+        if (value > 0) {
+            buckets[index] = value;
+        }
+    });
+    return {
+        layout,
+        count,
+        ...(count > 0 ? { mean: toNumber(distribution.mean) * scale } : {}),
+        buckets,
+    };
+}
+/**
+ * Converts the value of a point to a {@link GraphMetricMeasure}.
+ *
+ * @param value The value of the point.
+ * @param metric The metric.
+ * @param period The alignment period, in seconds.
+ * @param layouts The registry of layouts.
+ * @returns The measure.
+ */
+export function toMeasure(value, metric, period, layouts) {
+    const scale = metric.scale ?? 1;
+    if (value.distributionValue) {
+        if (metric.countRate) {
+            return toNumber(value.distributionValue.count) / period;
+        }
+        return toGraphDistribution(value.distributionValue, scale, metric.metricType, layouts);
+    }
+    return toNumber(value.doubleValue ?? value.int64Value) * scale;
+}

package/dist/graph/environment/resource-resolvers.d.ts

@@ -0,0 +1,7 @@
+import type { GraphResourcePrefixResolver } from '@causa/workspace-core';
+/**
+ * Resolves the names of Cloud Tasks queues, whose name ends with a suffix that is not known from the workspace.
+ * Queues are listed once per project and location, and matched on the longest prefix, as a prefix may be the beginning
+ * of another one. At most one queue is expected to match a prefix.
+ */
+export declare const CLOUD_TASKS_QUEUE_RESOLVER: GraphResourcePrefixResolver;

package/dist/graph/environment/resource-resolvers.js

@@ -0,0 +1,57 @@
+import { parseResourceName } from './resources.js';
+/**
+ * Resolves the names of Cloud Tasks queues, whose name ends with a suffix that is not known from the workspace.
+ * Queues are listed once per project and location, and matched on the longest prefix, as a prefix may be the beginning
+ * of another one. At most one queue is expected to match a prefix.
+ */
+export const CLOUD_TASKS_QUEUE_RESOLVER = {
+    resourceType: 'cloudtasks.googleapis.com/Queue',
+    resolve: async (context, prefixes) => {
+        const byParent = Map.groupBy(prefixes, ({ prefix }) => {
+            const segments = parseResourceName(prefix);
+            return `projects/${segments.projects}/locations/${segments.locations}`;
+        });
+        const { GoogleApisService } = await import('../../services/google-apis.js');
+        const client = await context
+            .service(GoogleApisService)
+            .getClient('cloudtasks', 'v2', {});
+        const ids = new Map();
+        const warnings = [];
+        await Promise.all([...byParent].map(async ([parent, prefixesOfParent]) => {
+            const queues = [];
+            try {
+                let pageToken;
+                do {
+                    const { data } = await client.projects.locations.queues.list({
+                        parent,
+                        pageSize: 1000,
+                        pageToken,
+                    });
+                    queues.push(...(data.queues ?? []).flatMap((q) => q.name ?? []));
+                    pageToken = data.nextPageToken ?? undefined;
+                } while (pageToken);
+            }
+            catch (error) {
+                warnings.push({
+                    message: `Failed to list the Cloud Tasks queues in '${parent}': ${error.message ?? error}`,
+                });
+                return;
+            }
+            const sorted = prefixesOfParent
+                .map(({ prefix }) => prefix)
+                .sort((a, b) => b.length - a.length);
+            const matchesByPrefix = Map.groupBy(queues.filter((q) => sorted.some((p) => q.startsWith(p))), (q) => sorted.find((p) => q.startsWith(p)));
+            for (const { node, prefix } of prefixesOfParent) {
+                const matches = matchesByPrefix.get(prefix) ?? [];
+                if (matches.length !== 1) {
+                    warnings.push({
+                        message: `Found ${matches.length} Cloud Tasks queues starting with '${prefix}' for '${node}', instead of one.`,
+                    });
+                    continue;
+                }
+                ids.set(node, matches[0]);
+            }
+        }));
+        return { ids, warnings };
+    },
+};