@rawdash/connector-gcp-monitoring 0.0.1

package/README.md

@@ -0,0 +1,113 @@
+<!-- This file is generated from connector metadata by scripts/generate-connector-docs.ts. Do not edit by hand. -->
+
+# @rawdash/connector-gcp-monitoring
+
+[![npm version](https://img.shields.io/npm/v/@rawdash/connector-gcp-monitoring)](https://www.npmjs.com/package/@rawdash/connector-gcp-monitoring)
+[![license](https://img.shields.io/npm/l/@rawdash/connector-gcp-monitoring)](https://github.com/rawdash/rawdash/blob/main/LICENSE)
+
+Pull declared Cloud Monitoring metric time series (any metric type, aligner, and period) into a single metric series per query.
+
+## Install
+
+```sh
+npm install @rawdash/connector-gcp-monitoring
+```
+
+## Authentication
+
+Authenticate against the Cloud Monitoring v3 API with a Google service account JSON key. The service account needs the Monitoring Viewer role (roles/monitoring.viewer) on the project whose metrics it reads.
+
+1. Identify the GCP project whose metrics you want to sync.
+2. Create a service account at Google Cloud -> IAM & Admin -> Service Accounts in that project (or grant an existing one access).
+3. Grant the service account the Monitoring Viewer role (roles/monitoring.viewer) on the project. The API enables this role automatically for owners and editors.
+4. Generate a JSON key for the service account and store its contents as a secret (e.g. GCP_MONITORING_SA_JSON).
+5. Reference the key from config as serviceAccountJson: secret("GCP_MONITORING_SA_JSON") and set projectId to the same project.
+
+## Configuration
+
+| Field                | Type   | Required | Description                                                                                                                                                                                                                               |
+| -------------------- | ------ | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `projectId`          | string | Yes      | Google Cloud project ID whose metrics should be synced (the project that owns the monitored resources).                                                                                                                                   |
+| `serviceAccountJson` | secret | Yes      | Contents of the JSON key file for a Google service account with the role required by this connector. Create one at Google Cloud -> IAM & Admin -> Service Accounts and store the JSON as a secret.                                        |
+| `metricQueries`      | array  | Yes      | Cloud Monitoring is too broad to mirror wholesale; declare the specific metrics to pull. Each query needs an id, metric type, alignment period (e.g. 300s), and a perSeriesAligner statistic, with an optional filter on resource labels. |
+| `lookbackMinutes`    | number | No       | How far back to pull data points on a full sync when the host does not supply a since bound. Defaults to 180.                                                                                                                             |
+
+## Resources
+
+- **`<metricType>`** _(metric)_ - One metric series per declared metric query. The series name is the configured metric type (e.g. `compute.googleapis.com/instance/cpu/utilization`), so the actual keys depend on the configured `metricQueries`. Each sample carries the aligner, alignment period, query id, and metric/resource labels as attributes.
+  - Endpoint: `GET /v3/projects/{projectId}/timeSeries`
+  - Granularity: Per alignmentPeriod (a duration in seconds, e.g. 300s)
+  - Dimensions: `perSeriesAligner`, `alignmentPeriod`, `queryId`, `resourceType`
+  - Each sync replaces the full set of samples for the metric names it owns (idempotent). Distribution-valued points are dropped unless reduced to a scalar by the perSeriesAligner.
+
+## Example
+
+```ts
+import {
+  defineConfig,
+  defineDashboard,
+  defineMetric,
+  secret,
+} from '@rawdash/core';
+
+const gcpMonitoring = {
+  name: 'gcpMonitoring',
+  connectorId: 'gcp-monitoring',
+  config: {
+    projectId: 'my-project-123',
+    serviceAccountJson: secret('GCP_MONITORING_SA_JSON'),
+    metricQueries: [
+      {
+        id: 'gce_cpu',
+        metricType: 'compute.googleapis.com/instance/cpu/utilization',
+        alignmentPeriod: '300s',
+        perSeriesAligner: 'ALIGN_MEAN',
+      },
+    ],
+    lookbackMinutes: 180,
+  },
+};
+
+export default defineConfig({
+  connectors: [gcpMonitoring],
+  dashboards: {
+    infra: defineDashboard({
+      widgets: {
+        cpu: {
+          kind: 'timeseries',
+          title: 'GCE CPU utilization',
+          window: '24h',
+          metric: defineMetric({
+            connector: gcpMonitoring,
+            shape: 'metric',
+            name: 'compute.googleapis.com/instance/cpu/utilization',
+            fn: 'avg',
+          }),
+        },
+      },
+    }),
+  },
+});
+```
+
+## Rate limits
+
+Cloud Monitoring projects.timeSeries.list is rate-limited per project; 429 / RESOURCE_EXHAUSTED responses are retried with backoff. Pagination uses nextPageToken.
+
+## Limitations
+
+- Cloud Monitoring is too broad to mirror wholesale; only the metrics declared in metricQueries are synced; there is no automatic metric discovery.
+- The series name is derived from the metric type, so two queries against the same metricType with different aligners or filters share one series name and are distinguished only by sample attributes.
+- Each query alignmentPeriod must be expressed as a duration in seconds, e.g. 60s or 300s.
+- A full sync uses lookbackMinutes; a latest sync uses a short window covering the last few alignment periods.
+- Distribution-valued metrics (e.g. latency histograms) require a perSeriesAligner that reduces them to a scalar (ALIGN_PERCENTILE_99, ALIGN_MEAN, etc.); raw distributions are not stored.
+
+## Links
+
+- [Rawdash docs](https://rawdash.dev/docs/connectors/)
+- [Google Cloud API docs](https://cloud.google.com/monitoring/api/v3)
+- [GitHub](https://github.com/rawdash/rawdash)
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,265 @@
+import { BaseConnector, ConnectorContext, SyncOptions, StorageHandle, SyncResult, ConnectorDoc, MetricSample } from '@rawdash/core';
+import { z } from 'zod';
+
+declare const configFields: z.ZodObject<{
+    metricQueries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        metricType: z.ZodString;
+        filter: z.ZodOptional<z.ZodString>;
+        alignmentPeriod: z.ZodString;
+        perSeriesAligner: z.ZodEnum<{
+            ALIGN_NONE: "ALIGN_NONE";
+            ALIGN_DELTA: "ALIGN_DELTA";
+            ALIGN_RATE: "ALIGN_RATE";
+            ALIGN_INTERPOLATE: "ALIGN_INTERPOLATE";
+            ALIGN_NEXT_OLDER: "ALIGN_NEXT_OLDER";
+            ALIGN_MIN: "ALIGN_MIN";
+            ALIGN_MAX: "ALIGN_MAX";
+            ALIGN_MEAN: "ALIGN_MEAN";
+            ALIGN_COUNT: "ALIGN_COUNT";
+            ALIGN_SUM: "ALIGN_SUM";
+            ALIGN_STDDEV: "ALIGN_STDDEV";
+            ALIGN_COUNT_TRUE: "ALIGN_COUNT_TRUE";
+            ALIGN_COUNT_FALSE: "ALIGN_COUNT_FALSE";
+            ALIGN_FRACTION_TRUE: "ALIGN_FRACTION_TRUE";
+            ALIGN_PERCENTILE_99: "ALIGN_PERCENTILE_99";
+            ALIGN_PERCENTILE_95: "ALIGN_PERCENTILE_95";
+            ALIGN_PERCENTILE_50: "ALIGN_PERCENTILE_50";
+            ALIGN_PERCENTILE_05: "ALIGN_PERCENTILE_05";
+            ALIGN_PERCENT_CHANGE: "ALIGN_PERCENT_CHANGE";
+        }>;
+    }, z.core.$strip>>;
+    lookbackMinutes: z.ZodOptional<z.ZodNumber>;
+    serviceAccountJson: z.ZodObject<{
+        $secret: z.ZodString;
+    }, z.core.$strip>;
+    projectId: z.ZodString;
+}, z.core.$strip>;
+declare const doc: ConnectorDoc;
+interface GcpMonitoringMetricQuery {
+    id: string;
+    metricType: string;
+    filter?: string;
+    alignmentPeriod: string;
+    perSeriesAligner: string;
+}
+interface GcpMonitoringSettings {
+    projectId: string;
+    metricQueries: GcpMonitoringMetricQuery[];
+    lookbackMinutes?: number;
+}
+declare const gcpMonitoringCredentials: {
+    serviceAccountJson: {
+        description: string;
+        auth: "required";
+    };
+};
+type GcpMonitoringCredentials = typeof gcpMonitoringCredentials;
+declare const pointSchema: z.ZodObject<{
+    interval: z.ZodObject<{
+        startTime: z.ZodOptional<z.ZodISODateTime>;
+        endTime: z.ZodISODateTime;
+    }, z.core.$strip>;
+    value: z.ZodObject<{
+        doubleValue: z.ZodOptional<z.ZodNumber>;
+        int64Value: z.ZodOptional<z.ZodString>;
+        boolValue: z.ZodOptional<z.ZodBoolean>;
+        stringValue: z.ZodOptional<z.ZodString>;
+        distributionValue: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const timeSeriesSchema: z.ZodObject<{
+    metric: z.ZodObject<{
+        type: z.ZodString;
+        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    resource: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    valueType: z.ZodOptional<z.ZodString>;
+    metricKind: z.ZodOptional<z.ZodString>;
+    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        interval: z.ZodObject<{
+            startTime: z.ZodOptional<z.ZodISODateTime>;
+            endTime: z.ZodISODateTime;
+        }, z.core.$strip>;
+        value: z.ZodObject<{
+            doubleValue: z.ZodOptional<z.ZodNumber>;
+            int64Value: z.ZodOptional<z.ZodString>;
+            boolValue: z.ZodOptional<z.ZodBoolean>;
+            stringValue: z.ZodOptional<z.ZodString>;
+            distributionValue: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const gcpMonitoringResources: {
+    readonly '<metricType>': {
+        readonly shape: "metric";
+        readonly dynamic: true;
+        readonly description: "One metric series per declared metric query. The series name is the configured metric type (e.g. `compute.googleapis.com/instance/cpu/utilization`), so the actual keys depend on the configured `metricQueries`. Each sample carries the aligner, alignment period, query id, and metric/resource labels as attributes.";
+        readonly endpoint: "GET /v3/projects/{projectId}/timeSeries";
+        readonly granularity: "Per alignmentPeriod (a duration in seconds, e.g. 300s)";
+        readonly notes: "Each sync replaces the full set of samples for the metric names it owns (idempotent). Distribution-valued points are dropped unless reduced to a scalar by the perSeriesAligner.";
+        readonly dimensions: [{
+            readonly name: "perSeriesAligner";
+            readonly description: "The Cloud Monitoring statistic requested for the query, e.g. ALIGN_MEAN, ALIGN_SUM, or ALIGN_PERCENTILE_99.";
+        }, {
+            readonly name: "alignmentPeriod";
+            readonly description: "The aggregation alignment period as configured, e.g. 300s.";
+        }, {
+            readonly name: "queryId";
+            readonly description: "The configured id of the metric query that produced the sample.";
+        }, {
+            readonly name: "resourceType";
+            readonly description: "The monitored resource type the sample originated from (e.g. gce_instance).";
+        }];
+        readonly responses: {
+            readonly oauth_token: z.ZodObject<{
+                access_token: z.ZodString;
+                expires_in: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            readonly time_series: z.ZodObject<{
+                timeSeries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    metric: z.ZodObject<{
+                        type: z.ZodString;
+                        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$strip>;
+                    resource: z.ZodOptional<z.ZodObject<{
+                        type: z.ZodOptional<z.ZodString>;
+                        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$strip>>;
+                    valueType: z.ZodOptional<z.ZodString>;
+                    metricKind: z.ZodOptional<z.ZodString>;
+                    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        interval: z.ZodObject<{
+                            startTime: z.ZodOptional<z.ZodISODateTime>;
+                            endTime: z.ZodISODateTime;
+                        }, z.core.$strip>;
+                        value: z.ZodObject<{
+                            doubleValue: z.ZodOptional<z.ZodNumber>;
+                            int64Value: z.ZodOptional<z.ZodString>;
+                            boolValue: z.ZodOptional<z.ZodBoolean>;
+                            stringValue: z.ZodOptional<z.ZodString>;
+                            distributionValue: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>>;
+                nextPageToken: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+    };
+};
+declare const id = "gcp-monitoring";
+declare class GcpMonitoringConnector extends BaseConnector<GcpMonitoringSettings, GcpMonitoringCredentials> {
+    static readonly id = "gcp-monitoring";
+    static readonly resources: {
+        readonly '<metricType>': {
+            readonly shape: "metric";
+            readonly dynamic: true;
+            readonly description: "One metric series per declared metric query. The series name is the configured metric type (e.g. `compute.googleapis.com/instance/cpu/utilization`), so the actual keys depend on the configured `metricQueries`. Each sample carries the aligner, alignment period, query id, and metric/resource labels as attributes.";
+            readonly endpoint: "GET /v3/projects/{projectId}/timeSeries";
+            readonly granularity: "Per alignmentPeriod (a duration in seconds, e.g. 300s)";
+            readonly notes: "Each sync replaces the full set of samples for the metric names it owns (idempotent). Distribution-valued points are dropped unless reduced to a scalar by the perSeriesAligner.";
+            readonly dimensions: [{
+                readonly name: "perSeriesAligner";
+                readonly description: "The Cloud Monitoring statistic requested for the query, e.g. ALIGN_MEAN, ALIGN_SUM, or ALIGN_PERCENTILE_99.";
+            }, {
+                readonly name: "alignmentPeriod";
+                readonly description: "The aggregation alignment period as configured, e.g. 300s.";
+            }, {
+                readonly name: "queryId";
+                readonly description: "The configured id of the metric query that produced the sample.";
+            }, {
+                readonly name: "resourceType";
+                readonly description: "The monitored resource type the sample originated from (e.g. gce_instance).";
+            }];
+            readonly responses: {
+                readonly oauth_token: z.ZodObject<{
+                    access_token: z.ZodString;
+                    expires_in: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+                readonly time_series: z.ZodObject<{
+                    timeSeries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        metric: z.ZodObject<{
+                            type: z.ZodString;
+                            labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        }, z.core.$strip>;
+                        resource: z.ZodOptional<z.ZodObject<{
+                            type: z.ZodOptional<z.ZodString>;
+                            labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        }, z.core.$strip>>;
+                        valueType: z.ZodOptional<z.ZodString>;
+                        metricKind: z.ZodOptional<z.ZodString>;
+                        points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            interval: z.ZodObject<{
+                                startTime: z.ZodOptional<z.ZodISODateTime>;
+                                endTime: z.ZodISODateTime;
+                            }, z.core.$strip>;
+                            value: z.ZodObject<{
+                                doubleValue: z.ZodOptional<z.ZodNumber>;
+                                int64Value: z.ZodOptional<z.ZodString>;
+                                boolValue: z.ZodOptional<z.ZodBoolean>;
+                                stringValue: z.ZodOptional<z.ZodString>;
+                                distributionValue: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>>;
+                    nextPageToken: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            };
+        };
+    };
+    static readonly schemas: {
+        readonly oauth_token: z.ZodObject<{
+            access_token: z.ZodString;
+            expires_in: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly time_series: z.ZodObject<{
+            timeSeries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                metric: z.ZodObject<{
+                    type: z.ZodString;
+                    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strip>;
+                resource: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodString>;
+                    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strip>>;
+                valueType: z.ZodOptional<z.ZodString>;
+                metricKind: z.ZodOptional<z.ZodString>;
+                points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    interval: z.ZodObject<{
+                        startTime: z.ZodOptional<z.ZodISODateTime>;
+                        endTime: z.ZodISODateTime;
+                    }, z.core.$strip>;
+                    value: z.ZodObject<{
+                        doubleValue: z.ZodOptional<z.ZodNumber>;
+                        int64Value: z.ZodOptional<z.ZodString>;
+                        boolValue: z.ZodOptional<z.ZodBoolean>;
+                        stringValue: z.ZodOptional<z.ZodString>;
+                        distributionValue: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            nextPageToken: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    } & Readonly<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    static create(input: unknown, ctx?: ConnectorContext): GcpMonitoringConnector;
+    readonly id = "gcp-monitoring";
+    readonly credentials: {
+        serviceAccountJson: {
+            description: string;
+            auth: "required";
+        };
+    };
+    private cachedToken;
+    private getAccessToken;
+    private computeWindow;
+    private buildFilter;
+    private listTimeSeries;
+    sync(options: SyncOptions, storage: StorageHandle, signal?: AbortSignal): Promise<SyncResult>;
+}
+declare function parseDurationSeconds(duration: string): number | null;
+declare function pointToSample(query: GcpMonitoringMetricQuery, series: z.infer<typeof timeSeriesSchema>, point: z.infer<typeof pointSchema>): MetricSample | null;
+
+export { GcpMonitoringConnector, type GcpMonitoringMetricQuery, type GcpMonitoringSettings, configFields, GcpMonitoringConnector as default, doc, id, parseDurationSeconds, pointToSample, gcpMonitoringResources as resources };

package/dist/index.js

@@ -0,0 +1,552 @@
+// ../gcp-shared/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+var serviceAccountKeySchema = z.object({
+  client_email: z.string().min(1),
+  private_key: z.string().min(1),
+  token_uri: z.string().url().optional(),
+  project_id: z.string().optional()
+});
+var tokenResponseSchema = z.object({
+  access_token: z.string().min(1),
+  expires_in: z.number().int().positive().optional()
+});
+function base64urlFromBytes(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64urlFromString(str) {
+  return base64urlFromBytes(new TextEncoder().encode(str));
+}
+async function signRS256JWT(payload, privateKeyPem) {
+  const header = { alg: "RS256", typ: "JWT" };
+  const headerB64 = base64urlFromString(JSON.stringify(header));
+  const payloadB64 = base64urlFromString(JSON.stringify(payload));
+  const signingInput = `${headerB64}.${payloadB64}`;
+  const pemContent = privateKeyPem.replace(/-----BEGIN PRIVATE KEY-----/g, "").replace(/-----END PRIVATE KEY-----/g, "").replace(/\s/g, "");
+  const der = Uint8Array.from(atob(pemContent), (c) => c.charCodeAt(0));
+  const key = await globalThis.crypto.subtle.importKey(
+    "pkcs8",
+    der,
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign(
+    "RSASSA-PKCS1-v1_5",
+    key,
+    new TextEncoder().encode(signingInput)
+  );
+  return `${signingInput}.${base64urlFromBytes(new Uint8Array(signature))}`;
+}
+function parseServiceAccountJson(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{")) {
+    return serviceAccountKeySchema.parse(JSON.parse(trimmed));
+  }
+  const binary = atob(trimmed);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  const decoded = new TextDecoder().decode(bytes);
+  return serviceAccountKeySchema.parse(JSON.parse(decoded));
+}
+async function buildServiceAccountJwt(serviceAccountJson, scope) {
+  const sa = parseServiceAccountJson(serviceAccountJson);
+  const now = Math.floor(Date.now() / 1e3);
+  const jwt = await signRS256JWT(
+    {
+      iss: sa.client_email,
+      scope,
+      aud: sa.token_uri ?? "https://oauth2.googleapis.com/token",
+      exp: now + 3600,
+      iat: now
+    },
+    sa.private_key
+  );
+  const body = new URLSearchParams({
+    grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+    assertion: jwt
+  }).toString();
+  return {
+    url: sa.token_uri ?? "https://oauth2.googleapis.com/token",
+    body
+  };
+}
+var gcpAuthConfigShape = {
+  serviceAccountJson: z2.object({ $secret: z2.string().trim().min(1) }).meta({
+    label: "Service Account JSON",
+    description: "Contents of the JSON key file for a Google service account with the role required by this connector. Create one at Google Cloud -> IAM & Admin -> Service Accounts and store the JSON as a secret.",
+    secret: true
+  })
+};
+
+// ../../connector-shared/dist/index.js
+var HttpClientError = class extends Error {
+  response;
+  constructor(message, response) {
+    super(message);
+    this.name = new.target.name;
+    this.response = response;
+  }
+};
+var AuthError = class extends HttpClientError {
+  kind = "auth";
+};
+var HTTP_CLIENT_VERSION = "0.0.0";
+var DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+function connectorUserAgent(connectorId) {
+  return `rawdash-connector-${connectorId}/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+}
+function parseEpoch(value, unit) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (unit === "iso") {
+    if (typeof value !== "string") {
+      return null;
+    }
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return null;
+  }
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) {
+    return null;
+  }
+  const result = unit === "s" ? n * 1e3 : n;
+  return Number.isFinite(result) ? result : null;
+}
+
+// src/gcp-monitoring.ts
+import {
+  BaseConnector,
+  defineConfigFields,
+  defineConnectorDoc,
+  defineResources,
+  schemasFromResources
+} from "@rawdash/core";
+import { z as z3 } from "zod";
+var metricQuerySchema = z3.object({
+  id: z3.string().regex(
+    /^[a-z][a-zA-Z0-9_]*$/,
+    "Monitoring query id must start with a lowercase letter and contain only letters, digits, and underscores"
+  ),
+  metricType: z3.string().min(1).meta({
+    description: "Fully-qualified Cloud Monitoring metric type, e.g. compute.googleapis.com/instance/cpu/utilization."
+  }),
+  filter: z3.string().optional().meta({
+    description: 'Optional additional filter combined with metric.type using AND, e.g. resource.labels.zone="us-central1-a".'
+  }),
+  alignmentPeriod: z3.string().regex(
+    /^\d+s$/,
+    "alignmentPeriod must be a duration in seconds, e.g. 60s or 300s"
+  ).meta({
+    description: "Aggregation alignment period as a duration in seconds, e.g. 300s."
+  }),
+  perSeriesAligner: z3.enum([
+    "ALIGN_NONE",
+    "ALIGN_DELTA",
+    "ALIGN_RATE",
+    "ALIGN_INTERPOLATE",
+    "ALIGN_NEXT_OLDER",
+    "ALIGN_MIN",
+    "ALIGN_MAX",
+    "ALIGN_MEAN",
+    "ALIGN_COUNT",
+    "ALIGN_SUM",
+    "ALIGN_STDDEV",
+    "ALIGN_COUNT_TRUE",
+    "ALIGN_COUNT_FALSE",
+    "ALIGN_FRACTION_TRUE",
+    "ALIGN_PERCENTILE_99",
+    "ALIGN_PERCENTILE_95",
+    "ALIGN_PERCENTILE_50",
+    "ALIGN_PERCENTILE_05",
+    "ALIGN_PERCENT_CHANGE"
+  ]).meta({
+    description: "Cloud Monitoring perSeriesAligner statistic, e.g. ALIGN_MEAN, ALIGN_SUM, ALIGN_PERCENTILE_99."
+  })
+});
+var configFields = defineConfigFields(
+  z3.object({
+    projectId: z3.string().min(1).meta({
+      label: "GCP project ID",
+      description: "Google Cloud project ID whose metrics should be synced (the project that owns the monitored resources).",
+      placeholder: "my-project-123"
+    }),
+    ...gcpAuthConfigShape,
+    metricQueries: z3.array(metricQuerySchema).nonempty().meta({
+      label: "Metric queries",
+      description: "Cloud Monitoring is too broad to mirror wholesale; declare the specific metrics to pull. Each query needs an id, metric type, alignment period (e.g. 300s), and a perSeriesAligner statistic, with an optional filter on resource labels."
+    }),
+    lookbackMinutes: z3.number().int().positive().max(40320).optional().meta({
+      label: "Lookback (minutes)",
+      description: "How far back to pull data points on a full sync when the host does not supply a since bound. Defaults to 180.",
+      placeholder: "180"
+    })
+  }).refine(
+    (cfg) => new Set(cfg.metricQueries.map((q) => q.id)).size === cfg.metricQueries.length,
+    {
+      path: ["metricQueries"],
+      message: "Each metric query id must be unique"
+    }
+  )
+);
+var doc = defineConnectorDoc({
+  displayName: "Google Cloud Monitoring",
+  category: "infrastructure",
+  brandColor: "#4285F4",
+  tagline: "Pull declared Cloud Monitoring metric time series (any metric type, aligner, and period) into a single metric series per query.",
+  rateLimit: "Cloud Monitoring projects.timeSeries.list is rate-limited per project; 429 / RESOURCE_EXHAUSTED responses are retried with backoff. Pagination uses nextPageToken.",
+  vendor: {
+    name: "Google Cloud",
+    apiDocs: "https://cloud.google.com/monitoring/api/v3",
+    website: "https://cloud.google.com/monitoring"
+  },
+  auth: {
+    summary: "Authenticate against the Cloud Monitoring v3 API with a Google service account JSON key. The service account needs the Monitoring Viewer role (roles/monitoring.viewer) on the project whose metrics it reads.",
+    setup: [
+      "Identify the GCP project whose metrics you want to sync.",
+      "Create a service account at Google Cloud -> IAM & Admin -> Service Accounts in that project (or grant an existing one access).",
+      "Grant the service account the Monitoring Viewer role (roles/monitoring.viewer) on the project. The API enables this role automatically for owners and editors.",
+      "Generate a JSON key for the service account and store its contents as a secret (e.g. GCP_MONITORING_SA_JSON).",
+      'Reference the key from config as serviceAccountJson: secret("GCP_MONITORING_SA_JSON") and set projectId to the same project.'
+    ]
+  },
+  limitations: [
+    "Cloud Monitoring is too broad to mirror wholesale; only the metrics declared in metricQueries are synced; there is no automatic metric discovery.",
+    "The series name is derived from the metric type, so two queries against the same metricType with different aligners or filters share one series name and are distinguished only by sample attributes.",
+    "Each query alignmentPeriod must be expressed as a duration in seconds, e.g. 60s or 300s.",
+    "A full sync uses lookbackMinutes; a latest sync uses a short window covering the last few alignment periods.",
+    "Distribution-valued metrics (e.g. latency histograms) require a perSeriesAligner that reduces them to a scalar (ALIGN_PERCENTILE_99, ALIGN_MEAN, etc.); raw distributions are not stored."
+  ]
+});
+var gcpMonitoringCredentials = {
+  serviceAccountJson: {
+    description: "Google service account JSON key (raw JSON or base64)",
+    auth: "required"
+  }
+};
+var int64String = z3.string().regex(/^-?\d+$/);
+var isoTimestamp = z3.iso.datetime();
+var pointValue = z3.object({
+  doubleValue: z3.number().optional(),
+  int64Value: int64String.optional(),
+  boolValue: z3.boolean().optional(),
+  stringValue: z3.string().optional(),
+  distributionValue: z3.unknown().optional()
+}).refine(
+  (v) => v.doubleValue !== void 0 || v.int64Value !== void 0 || v.boolValue !== void 0 || v.stringValue !== void 0 || v.distributionValue !== void 0,
+  {
+    message: "point value must carry at least one supported value field"
+  }
+);
+var pointSchema = z3.object({
+  interval: z3.object({
+    startTime: isoTimestamp.optional(),
+    endTime: isoTimestamp
+  }),
+  value: pointValue
+});
+var timeSeriesSchema = z3.object({
+  metric: z3.object({
+    type: z3.string(),
+    labels: z3.record(z3.string(), z3.string()).optional()
+  }),
+  resource: z3.object({
+    type: z3.string().optional(),
+    labels: z3.record(z3.string(), z3.string()).optional()
+  }).optional(),
+  valueType: z3.string().optional(),
+  metricKind: z3.string().optional(),
+  points: z3.array(pointSchema).optional()
+});
+var listTimeSeriesResponseSchema = z3.object({
+  timeSeries: z3.array(timeSeriesSchema).optional(),
+  nextPageToken: z3.string().optional()
+});
+var gcpMonitoringResources = defineResources({
+  "<metricType>": {
+    shape: "metric",
+    dynamic: true,
+    description: "One metric series per declared metric query. The series name is the configured metric type (e.g. `compute.googleapis.com/instance/cpu/utilization`), so the actual keys depend on the configured `metricQueries`. Each sample carries the aligner, alignment period, query id, and metric/resource labels as attributes.",
+    endpoint: "GET /v3/projects/{projectId}/timeSeries",
+    granularity: "Per alignmentPeriod (a duration in seconds, e.g. 300s)",
+    notes: "Each sync replaces the full set of samples for the metric names it owns (idempotent). Distribution-valued points are dropped unless reduced to a scalar by the perSeriesAligner.",
+    dimensions: [
+      {
+        name: "perSeriesAligner",
+        description: "The Cloud Monitoring statistic requested for the query, e.g. ALIGN_MEAN, ALIGN_SUM, or ALIGN_PERCENTILE_99."
+      },
+      {
+        name: "alignmentPeriod",
+        description: "The aggregation alignment period as configured, e.g. 300s."
+      },
+      {
+        name: "queryId",
+        description: "The configured id of the metric query that produced the sample."
+      },
+      {
+        name: "resourceType",
+        description: "The monitored resource type the sample originated from (e.g. gce_instance)."
+      }
+    ],
+    responses: {
+      oauth_token: tokenResponseSchema,
+      time_series: listTimeSeriesResponseSchema
+    }
+  }
+});
+var MONITORING_API_BASE = "https://monitoring.googleapis.com/v3";
+var MONITORING_SCOPE = "https://www.googleapis.com/auth/monitoring.read";
+var PAGE_SIZE = 1e3;
+var DEFAULT_LOOKBACK_MINUTES = 180;
+var MS_PER_MINUTE = 6e4;
+var id = "gcp-monitoring";
+var GcpMonitoringConnector = class _GcpMonitoringConnector extends BaseConnector {
+  static id = id;
+  static resources = gcpMonitoringResources;
+  static schemas = schemasFromResources(gcpMonitoringResources);
+  static create(input, ctx) {
+    const parsed = configFields.parse(input);
+    return new _GcpMonitoringConnector(
+      {
+        projectId: parsed.projectId,
+        metricQueries: parsed.metricQueries,
+        lookbackMinutes: parsed.lookbackMinutes
+      },
+      {
+        serviceAccountJson: parsed.serviceAccountJson
+      },
+      ctx
+    );
+  }
+  id = id;
+  credentials = gcpMonitoringCredentials;
+  cachedToken = null;
+  async getAccessToken(signal) {
+    if (this.cachedToken && Date.now() < this.cachedToken.expiresAt) {
+      return this.cachedToken.token;
+    }
+    const { serviceAccountJson } = this.creds;
+    if (!serviceAccountJson) {
+      throw new AuthError(`${this.id}: missing serviceAccountJson credential`);
+    }
+    const { url, body } = await buildServiceAccountJwt(
+      serviceAccountJson,
+      MONITORING_SCOPE
+    );
+    const res = await this.post(url, {
+      resource: "oauth_token",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+      signal
+    });
+    const expiresIn = res.body.expires_in ?? 3600;
+    this.cachedToken = {
+      token: res.body.access_token,
+      expiresAt: Date.now() + (expiresIn - 60) * 1e3
+    };
+    return this.cachedToken.token;
+  }
+  computeWindow(options) {
+    const endMs = Date.now();
+    if (options.since) {
+      const sinceMs = parseEpoch(options.since, "iso");
+      if (sinceMs !== null) {
+        return { startMs: Math.min(sinceMs, endMs), endMs };
+      }
+    }
+    if (options.mode === "latest") {
+      const maxPeriodSec = Math.max(
+        ...this.settings.metricQueries.map(
+          (q) => parseDurationSeconds(q.alignmentPeriod) ?? 60
+        ),
+        60
+      );
+      return { startMs: endMs - maxPeriodSec * 3 * 1e3, endMs };
+    }
+    const lookback = this.settings.lookbackMinutes ?? DEFAULT_LOOKBACK_MINUTES;
+    return { startMs: endMs - lookback * MS_PER_MINUTE, endMs };
+  }
+  buildFilter(query) {
+    const base = `metric.type = "${query.metricType}"`;
+    if (query.filter && query.filter.trim().length > 0) {
+      return `${base} AND ${query.filter}`;
+    }
+    return base;
+  }
+  async listTimeSeries(accessToken, query, startMs, endMs, pageToken, signal) {
+    const params = new URLSearchParams();
+    params.set("filter", this.buildFilter(query));
+    params.set("interval.startTime", new Date(startMs).toISOString());
+    params.set("interval.endTime", new Date(endMs).toISOString());
+    params.set("aggregation.alignmentPeriod", query.alignmentPeriod);
+    params.set("aggregation.perSeriesAligner", query.perSeriesAligner);
+    params.set("pageSize", String(PAGE_SIZE));
+    if (pageToken !== void 0) {
+      params.set("pageToken", pageToken);
+    }
+    const url = `${MONITORING_API_BASE}/projects/${encodeURIComponent(
+      this.settings.projectId
+    )}/timeSeries?${params.toString()}`;
+    const res = await this.get(
+      url,
+      {
+        resource: "time_series",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "User-Agent": connectorUserAgent(this.id)
+        },
+        signal
+      }
+    );
+    return res.body;
+  }
+  async sync(options, storage, signal) {
+    const queries = this.settings.metricQueries;
+    if (queries.length === 0) {
+      return { done: true };
+    }
+    const names = new Set(queries.map((q) => q.metricType));
+    const { startMs, endMs } = this.computeWindow(options);
+    let token = null;
+    const getToken = async (sig) => {
+      if (token === null) {
+        token = await this.getAccessToken(sig);
+      }
+      return token;
+    };
+    const samples = [];
+    for (const query of queries) {
+      let pageToken;
+      let page = 0;
+      let pageItems = 0;
+      let total = 0;
+      const phaseStart = Date.now();
+      do {
+        if (signal?.aborted) {
+          return { done: false };
+        }
+        let response;
+        try {
+          const accessToken = await getToken(signal);
+          response = await this.listTimeSeries(
+            accessToken,
+            query,
+            startMs,
+            endMs,
+            pageToken,
+            signal
+          );
+        } catch (err) {
+          this.logger.warn("fetch page failed", {
+            resource: query.metricType,
+            page: page + 1,
+            queryId: query.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+          throw err;
+        }
+        const series = response.timeSeries ?? [];
+        pageItems = 0;
+        for (const ts of series) {
+          for (const point of ts.points ?? []) {
+            const sample = pointToSample(query, ts, point);
+            if (sample !== null) {
+              samples.push(sample);
+              pageItems += 1;
+            }
+          }
+        }
+        total += pageItems;
+        pageToken = typeof response.nextPageToken === "string" && response.nextPageToken.length > 0 ? response.nextPageToken : void 0;
+        page += 1;
+        this.logger.info("fetched page", {
+          resource: query.metricType,
+          queryId: query.id,
+          page,
+          items: pageItems,
+          next: pageToken ?? null
+        });
+      } while (pageToken !== void 0);
+      this.logger.info("resource done", {
+        resource: query.metricType,
+        queryId: query.id,
+        pages: page,
+        items: total,
+        duration_ms: Date.now() - phaseStart
+      });
+    }
+    await storage.metrics(samples, { names: [...names] });
+    return { done: true };
+  }
+};
+function parseDurationSeconds(duration) {
+  const m = /^(\d+)s$/.exec(duration);
+  if (!m) {
+    return null;
+  }
+  const n = Number.parseInt(m[1], 10);
+  return Number.isFinite(n) ? n : null;
+}
+function pointToSample(query, series, point) {
+  const tsIso = point.interval.endTime;
+  const ts = parseEpoch(tsIso, "iso");
+  if (ts === null) {
+    return null;
+  }
+  const value = extractScalarValue(point.value);
+  if (value === null) {
+    return null;
+  }
+  const attributes = {
+    perSeriesAligner: query.perSeriesAligner,
+    alignmentPeriod: query.alignmentPeriod,
+    queryId: query.id
+  };
+  if (series.resource?.type) {
+    attributes["resourceType"] = series.resource.type;
+  }
+  for (const [k, v] of Object.entries(series.metric.labels ?? {})) {
+    attributes[`metric.${k}`] = v;
+  }
+  for (const [k, v] of Object.entries(series.resource?.labels ?? {})) {
+    attributes[`resource.${k}`] = v;
+  }
+  return { name: query.metricType, ts, value, attributes };
+}
+function extractScalarValue(v) {
+  if (v.doubleValue !== void 0 && Number.isFinite(v.doubleValue)) {
+    return v.doubleValue;
+  }
+  if (v.int64Value !== void 0) {
+    const n = Number(v.int64Value);
+    return Number.isSafeInteger(n) ? n : null;
+  }
+  if (v.boolValue !== void 0) {
+    return v.boolValue ? 1 : 0;
+  }
+  return null;
+}
+
+// src/index.ts
+var index_default = GcpMonitoringConnector;
+export {
+  GcpMonitoringConnector,
+  configFields,
+  index_default as default,
+  doc,
+  id,
+  parseDurationSeconds,
+  pointToSample,
+  gcpMonitoringResources as resources
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../gcp-shared/src/auth.ts","../../gcp-shared/src/config.ts","../../../connector-shared/src/errors.ts","../../../connector-shared/src/retry.ts","../../../connector-shared/src/version.ts","../../../connector-shared/src/request.ts","../../../connector-shared/src/rate-limit.ts","../../../connector-shared/src/sanitize.ts","../../../connector-shared/src/epoch.ts","../../../connector-shared/src/pagination.ts","../../../connector-shared/src/logger.ts","../src/gcp-monitoring.ts","../src/index.ts"],"sourcesContent":["import { z } from 'zod';\n\nexport interface ServiceAccountKey {\n  client_email: string;\n  private_key: string;\n  token_uri?: string;\n  project_id?: string;\n}\n\nconst serviceAccountKeySchema = z.object({\n  client_email: z.string().min(1),\n  private_key: z.string().min(1),\n  token_uri: z.string().url().optional(),\n  project_id: z.string().optional(),\n});\n\nexport interface TokenResponse {\n  access_token: string;\n  expires_in?: number;\n}\n\nexport const tokenResponseSchema = z.object({\n  access_token: z.string().min(1),\n  expires_in: z.number().int().positive().optional(),\n});\n\nfunction base64urlFromBytes(bytes: Uint8Array): string {\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]!);\n  }\n  return btoa(binary).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=/g, '');\n}\n\nfunction base64urlFromString(str: string): string {\n  return base64urlFromBytes(new TextEncoder().encode(str));\n}\n\nasync function signRS256JWT(\n  payload: Record<string, unknown>,\n  privateKeyPem: string,\n): Promise<string> {\n  const header = { alg: 'RS256', typ: 'JWT' };\n  const headerB64 = base64urlFromString(JSON.stringify(header));\n  const payloadB64 = base64urlFromString(JSON.stringify(payload));\n  const signingInput = `${headerB64}.${payloadB64}`;\n\n  const pemContent = privateKeyPem\n    .replace(/-----BEGIN PRIVATE KEY-----/g, '')\n    .replace(/-----END PRIVATE KEY-----/g, '')\n    .replace(/\\s/g, '');\n  const der = Uint8Array.from(atob(pemContent), (c) => c.charCodeAt(0));\n\n  const key = await globalThis.crypto.subtle.importKey(\n    'pkcs8',\n    der,\n    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },\n    false,\n    ['sign'],\n  );\n\n  const signature = await globalThis.crypto.subtle.sign(\n    'RSASSA-PKCS1-v1_5',\n    key,\n    new TextEncoder().encode(signingInput),\n  );\n\n  return `${signingInput}.${base64urlFromBytes(new Uint8Array(signature))}`;\n}\n\nexport function parseServiceAccountJson(value: string): ServiceAccountKey {\n  const trimmed = value.trim();\n  if (trimmed.startsWith('{')) {\n    return serviceAccountKeySchema.parse(JSON.parse(trimmed));\n  }\n  const binary = atob(trimmed);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  const decoded = new TextDecoder().decode(bytes);\n  return serviceAccountKeySchema.parse(JSON.parse(decoded));\n}\n\n/**\n * Build the OAuth 2.0 token-exchange request body for a Google service account.\n * The caller posts the returned body to the returned url and parses the\n * resulting `access_token` (see {@link tokenResponseSchema}).\n *\n * Scope is a space-delimited list of OAuth scope URLs (e.g.\n * `https://www.googleapis.com/auth/monitoring.read`).\n */\nexport async function buildServiceAccountJwt(\n  serviceAccountJson: string,\n  scope: string,\n): Promise<{ url: string; body: string }> {\n  const sa = parseServiceAccountJson(serviceAccountJson);\n  const now = Math.floor(Date.now() / 1000);\n  const jwt = await signRS256JWT(\n    {\n      iss: sa.client_email,\n      scope,\n      aud: sa.token_uri ?? 'https://oauth2.googleapis.com/token',\n      exp: now + 3600,\n      iat: now,\n    },\n    sa.private_key,\n  );\n\n  const body = new URLSearchParams({\n    grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',\n    assertion: jwt,\n  }).toString();\n\n  return {\n    url: sa.token_uri ?? 'https://oauth2.googleapis.com/token',\n    body,\n  };\n}\n","import { z } from 'zod';\n\n/**\n * Shared GCP config fragment - reused by both `@rawdash/connector-gcp-monitoring`\n * and `@rawdash/connector-gcp-billing`. Both authenticate with a service-account\n * JSON key; the per-connector schema spreads this in alongside its own fields.\n */\nexport const gcpAuthConfigShape = {\n  serviceAccountJson: z.object({ $secret: z.string().trim().min(1) }).meta({\n    label: 'Service Account JSON',\n    description:\n      'Contents of the JSON key file for a Google service account with the role required by this connector. Create one at Google Cloud -> IAM & Admin -> Service Accounts and store the JSON as a secret.',\n    secret: true,\n  }),\n} as const;\n\nexport interface GcpAuthConfig {\n  serviceAccountJson: { $secret: string };\n}\n","import type { HttpResponse } from './types';\n\nexport type HttpErrorKind =\n  | 'transient'\n  | 'rate_limit'\n  | 'auth'\n  | 'upstream_bug'\n  | 'client_bug';\n\nexport abstract class HttpClientError extends Error {\n  abstract readonly kind: HttpErrorKind;\n  readonly response?: HttpResponse;\n\n  constructor(message: string, response?: HttpResponse) {\n    super(message);\n    this.name = new.target.name;\n    this.response = response;\n  }\n}\n\nexport class TransientError extends HttpClientError {\n  readonly kind = 'transient' as const;\n}\n\nexport class RateLimitError extends HttpClientError {\n  readonly kind = 'rate_limit' as const;\n  readonly retryAfter?: Date;\n\n  constructor(message: string, response?: HttpResponse, retryAfter?: Date) {\n    super(message, response);\n    this.retryAfter = retryAfter;\n  }\n}\n\nexport class AuthError extends HttpClientError {\n  readonly kind = 'auth' as const;\n}\n\nexport class UpstreamBugError extends HttpClientError {\n  readonly kind = 'upstream_bug' as const;\n}\n\nexport class ClientBugError extends HttpClientError {\n  readonly kind = 'client_bug' as const;\n}\n\nexport function classifyStatus(status: number): HttpErrorKind {\n  if (status === 429) {\n    return 'rate_limit';\n  }\n  if (status === 401 || status === 403) {\n    return 'auth';\n  }\n  if (status === 408) {\n    return 'transient';\n  }\n  if (status >= 500) {\n    return 'upstream_bug';\n  }\n  if (status >= 400) {\n    return 'client_bug';\n  }\n  return 'client_bug';\n}\n\nexport function errorForStatus(\n  message: string,\n  response: HttpResponse,\n  retryAfter?: Date,\n): HttpClientError {\n  const kind = classifyStatus(response.status);\n  switch (kind) {\n    case 'rate_limit':\n      return new RateLimitError(message, response, retryAfter);\n    case 'auth':\n      return new AuthError(message, response);\n    case 'transient':\n      return new TransientError(message, response);\n    case 'upstream_bug':\n      return new UpstreamBugError(message, response);\n    case 'client_bug':\n      return new ClientBugError(message, response);\n  }\n}\n","import { HttpClientError, RateLimitError, TransientError } from './errors';\n\nexport interface RetryPolicy {\n  maxAttempts?: number;\n  initialDelayMs?: number;\n  maxDelayMs?: number;\n  retryOn?: (status: number | null, err?: Error) => boolean;\n}\n\nexport const defaultRetryOn = (status: number | null, err?: Error): boolean => {\n  if (err instanceof RateLimitError) {\n    return true;\n  }\n  if (err instanceof TransientError) {\n    return true;\n  }\n  if (status === null) {\n    return err instanceof Error && !(err instanceof HttpClientError);\n  }\n  if (status === 408 || status === 429) {\n    return true;\n  }\n  if (status >= 500) {\n    return true;\n  }\n  return false;\n};\n\nexport function backoffDelayMs(\n  attempt: number,\n  policy: Required<Pick<RetryPolicy, 'initialDelayMs' | 'maxDelayMs'>>,\n): number {\n  const base = policy.initialDelayMs * 2 ** attempt;\n  const jitter = base * 0.25 * Math.random();\n  return Math.min(base + jitter, policy.maxDelayMs);\n}\n\nexport function parseRetryAfter(\n  headerValue: string | null,\n  now: Date = new Date(),\n): Date | undefined {\n  if (!headerValue) {\n    return undefined;\n  }\n  const trimmed = headerValue.trim();\n  if (/^\\d+$/.test(trimmed)) {\n    return new Date(now.getTime() + Number(trimmed) * 1000);\n  }\n  const parsed = Date.parse(trimmed);\n  if (Number.isNaN(parsed)) {\n    return undefined;\n  }\n  return new Date(parsed);\n}\n\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  if (signal?.aborted) {\n    return Promise.reject(signal.reason ?? new Error('Aborted'));\n  }\n  return new Promise<void>((resolve, reject) => {\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(signal!.reason ?? new Error('Aborted'));\n    };\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n","export const HTTP_CLIENT_VERSION = '0.0.0';\n\nexport const DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;\n\nexport function connectorUserAgent(connectorId: string): string {\n  return `rawdash-connector-${connectorId}/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;\n}\n","import {\n  AuthError,\n  ClientBugError,\n  HttpClientError,\n  RateLimitError,\n  TransientError,\n  UpstreamBugError,\n  errorForStatus,\n} from './errors';\nimport { defaultRetryOn, parseRetryAfter, sleep } from './retry';\nimport type { FetchLike, HttpMethod, HttpRequest, HttpResponse } from './types';\nimport { DEFAULT_USER_AGENT } from './version';\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\nconst DEFAULT_MAX_ATTEMPTS = 3;\nconst DEFAULT_INITIAL_DELAY_MS = 1000;\nconst DEFAULT_MAX_DELAY_MS = 60_000;\nconst OBSERVER_TIMEOUT_MS = 250;\n\nexport interface RequestObservation {\n  url: string;\n  method: HttpMethod;\n  status: number;\n  resource: string;\n  requestId: string;\n  body: unknown;\n}\n\nexport type RequestObserver = (\n  event: RequestObservation,\n) => void | Promise<void>;\n\nexport interface RequestOptions {\n  fetch?: FetchLike;\n  observer?: RequestObserver;\n  resource: string;\n  requestId?: string;\n}\n\nasync function notifyObserver(\n  observer: RequestObserver,\n  event: RequestObservation,\n): Promise<void> {\n  let result: void | Promise<void>;\n  try {\n    result = observer(event);\n  } catch (err) {\n    console.warn('[connector-shared] request observer threw:', err);\n    return;\n  }\n  if (!(result instanceof Promise)) {\n    return;\n  }\n  const guarded = result.catch((err) => {\n    console.warn('[connector-shared] request observer rejected:', err);\n  });\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const timeout = new Promise<void>((resolve) => {\n    timer = setTimeout(resolve, OBSERVER_TIMEOUT_MS);\n  });\n  try {\n    await Promise.race([guarded, timeout]);\n  } finally {\n    if (timer) {\n      clearTimeout(timer);\n    }\n  }\n}\n\nfunction newRequestId(): string {\n  const c = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (c?.randomUUID) {\n    return c.randomUUID();\n  }\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\nfunction mergeHeaders(\n  defaults: Record<string, string>,\n  overrides: Record<string, string> | undefined,\n): Record<string, string> {\n  const merged: Record<string, string> = {};\n  for (const [k, v] of Object.entries(defaults)) {\n    merged[k.toLowerCase()] = v;\n  }\n  if (overrides) {\n    for (const [k, v] of Object.entries(overrides)) {\n      merged[k.toLowerCase()] = v;\n    }\n  }\n  return merged;\n}\n\nfunction linkTimeoutSignal(\n  parent: AbortSignal | undefined,\n  timeoutMs: number,\n): { signal: AbortSignal; cancel: () => void } {\n  const controller = new AbortController();\n  const onParentAbort = () => {\n    controller.abort(parent?.reason);\n  };\n  if (parent) {\n    if (parent.aborted) {\n      controller.abort(parent.reason);\n    } else {\n      parent.addEventListener('abort', onParentAbort, { once: true });\n    }\n  }\n  const timer = setTimeout(() => {\n    controller.abort(new Error(`Request timed out after ${timeoutMs}ms`));\n  }, timeoutMs);\n  return {\n    signal: controller.signal,\n    cancel: () => {\n      clearTimeout(timer);\n      if (parent) {\n        parent.removeEventListener('abort', onParentAbort);\n      }\n    },\n  };\n}\n\nasync function readBody(res: Response, parseJson: boolean): Promise<unknown> {\n  if (res.status === 204 || res.status === 205) {\n    return null;\n  }\n  const contentType = res.headers.get('content-type') ?? '';\n  if (parseJson && contentType.includes('application/json')) {\n    const text = await res.text();\n    if (text.length === 0) {\n      return null;\n    }\n    return JSON.parse(text);\n  }\n  return res.text();\n}\n\nexport async function request<T = unknown>(\n  req: HttpRequest,\n  options: RequestOptions,\n): Promise<HttpResponse<T>> {\n  const fetchImpl: FetchLike = options.fetch ?? (globalThis.fetch as FetchLike);\n  const retry = req.retry ?? {};\n  const maxAttempts = retry.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;\n  const initialDelayMs = retry.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;\n  const maxDelayMs = retry.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;\n  const retryOn = retry.retryOn ?? defaultRetryOn;\n  const timeoutMs = req.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  const parseJson = req.parseJson ?? true;\n\n  const headers = mergeHeaders(\n    {\n      'User-Agent': DEFAULT_USER_AGENT,\n      Accept: 'application/json',\n    },\n    req.headers,\n  );\n\n  let lastErr: Error | undefined;\n\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    req.signal?.throwIfAborted();\n\n    const { signal, cancel } = linkTimeoutSignal(req.signal, timeoutMs);\n    let res: Response;\n    try {\n      res = await fetchImpl(req.url, {\n        method: req.method ?? 'GET',\n        headers,\n        body: req.body as RequestInit['body'],\n        signal,\n      });\n    } catch (err) {\n      cancel();\n      if (req.signal?.aborted) {\n        throw req.signal.reason ?? err;\n      }\n      const error = err instanceof Error ? err : new Error(String(err));\n      lastErr = error;\n      if (attempt < maxAttempts - 1 && retryOn(null, error)) {\n        const delay = computeDelay(attempt, initialDelayMs, maxDelayMs);\n        await sleep(delay, req.signal);\n        continue;\n      }\n      throw new TransientError(error.message);\n    }\n    cancel();\n\n    const body = await readBody(res, parseJson);\n    const httpResponse: HttpResponse<T> = {\n      status: res.status,\n      headers: res.headers,\n      body: body as T,\n    };\n    if (req.rateLimit) {\n      const state = req.rateLimit.parse(res.headers);\n      if (state) {\n        httpResponse.rateLimitState = state;\n      }\n    }\n\n    if (options.observer) {\n      await notifyObserver(options.observer, {\n        url: req.url,\n        method: req.method ?? 'GET',\n        status: res.status,\n        resource: options.resource,\n        requestId: options.requestId ?? newRequestId(),\n        body,\n      });\n    }\n\n    if (res.ok) {\n      return httpResponse;\n    }\n\n    const retryAfter = parseRetryAfter(res.headers.get('retry-after'));\n    const message = `HTTP ${res.status} ${res.statusText} for ${req.method ?? 'GET'} ${req.url}`;\n    const err = errorForStatus(message, httpResponse, retryAfter);\n\n    if (\n      attempt < maxAttempts - 1 &&\n      retryOn(res.status, err) &&\n      !(err instanceof AuthError) &&\n      !(err instanceof ClientBugError)\n    ) {\n      lastErr = err;\n      let delay = computeDelay(attempt, initialDelayMs, maxDelayMs);\n      if (err instanceof RateLimitError && retryAfter) {\n        const wait = retryAfter.getTime() - Date.now();\n        if (wait > 0) {\n          delay = Math.min(wait, maxDelayMs);\n        }\n      }\n      await sleep(delay, req.signal);\n      continue;\n    }\n\n    throw err;\n  }\n\n  throw lastErr ?? new UpstreamBugError('Exhausted retry attempts');\n}\n\nfunction computeDelay(\n  attempt: number,\n  initialDelayMs: number,\n  maxDelayMs: number,\n): number {\n  const base = initialDelayMs * 2 ** attempt;\n  const jitter = base * 0.25 * Math.random();\n  return Math.min(base + jitter, maxDelayMs);\n}\n\nexport { HttpClientError };\n","export interface RateLimitState {\n  remaining: number;\n  resetAt: Date;\n}\n\nexport interface RateLimitPolicy {\n  parse(headers: Headers): RateLimitState | null;\n}\n\nexport interface StandardRateLimitPolicyConfig {\n  remainingHeader: string;\n  resetHeader: string;\n  resetUnit: 's' | 'ms';\n  resetFallbackMs?: number;\n}\n\nexport function standardRateLimitPolicy(\n  config: StandardRateLimitPolicyConfig,\n): RateLimitPolicy {\n  const { remainingHeader, resetHeader, resetUnit, resetFallbackMs } = config;\n  const multiplier = resetUnit === 's' ? 1000 : 1;\n  return {\n    parse(h) {\n      const remainingRaw = h.get(remainingHeader);\n      if (remainingRaw === null || remainingRaw.trim() === '') {\n        return null;\n      }\n      const remaining = Number(remainingRaw);\n      if (!Number.isFinite(remaining)) {\n        return null;\n      }\n      const resetRaw = h.get(resetHeader);\n      if (resetRaw === null) {\n        if (resetFallbackMs === undefined) {\n          return null;\n        }\n        return {\n          remaining,\n          resetAt: new Date(Date.now() + resetFallbackMs),\n        };\n      }\n      if (resetRaw.trim() === '') {\n        return null;\n      }\n      const reset = Number(resetRaw);\n      if (!Number.isFinite(reset) || reset < 0) {\n        return null;\n      }\n      const resetMs = reset * multiplier;\n      if (!Number.isFinite(resetMs)) {\n        return null;\n      }\n      return { remaining, resetAt: new Date(resetMs) };\n    },\n  };\n}\n","export interface SanitizeAllowedUrlOptions {\n  url: string | null;\n  host: string;\n  pathname: string;\n  protocol?: 'https:' | 'http:';\n}\n\nexport function sanitizeAllowedUrl(\n  options: SanitizeAllowedUrlOptions,\n): string | null {\n  const { url, host, pathname, protocol = 'https:' } = options;\n  if (url === null) {\n    return null;\n  }\n  try {\n    const u = new URL(url);\n    if (u.protocol !== protocol || u.host !== host || u.pathname !== pathname) {\n      return null;\n    }\n    return u.toString();\n  } catch {\n    return null;\n  }\n}\n","export type EpochUnit = 'ms' | 's' | 'iso';\n\nexport function parseEpoch(\n  value: number | string | null | undefined,\n  unit: EpochUnit,\n): number | null {\n  if (value === null || value === undefined) {\n    return null;\n  }\n  if (unit === 'iso') {\n    if (typeof value !== 'string') {\n      return null;\n    }\n    const ms = new Date(value).getTime();\n    return Number.isFinite(ms) ? ms : null;\n  }\n  if (typeof value === 'string' && value.trim() === '') {\n    return null;\n  }\n  const n = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(n)) {\n    return null;\n  }\n  const result = unit === 's' ? n * 1000 : n;\n  return Number.isFinite(result) ? result : null;\n}\n","import { request } from './request';\nimport type { HttpRequest } from './types';\n\nexport function parseLinkHeader(header: string | null): Record<string, string> {\n  if (!header) {\n    return {};\n  }\n  const result: Record<string, string> = {};\n  for (const part of header.split(',')) {\n    const match = part.match(/<([^>]+)>\\s*;\\s*rel=\"([^\"]+)\"/);\n    if (match) {\n      result[match[2]!] = match[1]!;\n    }\n  }\n  return result;\n}\n\nexport async function* paginateLink<T>(\n  initial: HttpRequest,\n  parse: (body: unknown) => T[],\n  options: { resource: string },\n): AsyncIterable<T> {\n  let next: string | null = initial.url;\n  while (next) {\n    const res: Awaited<ReturnType<typeof request>> = await request(\n      {\n        ...initial,\n        url: next,\n      },\n      { resource: options.resource },\n    );\n    for (const item of parse(res.body)) {\n      yield item;\n    }\n    const links = parseLinkHeader(res.headers.get('link'));\n    next = links['next'] ?? null;\n  }\n}\n\nexport async function* paginateCursor<T>(\n  initial: HttpRequest,\n  parse: (body: unknown) => { items: T[]; nextCursor: string | null },\n  buildNext: (req: HttpRequest, cursor: string) => HttpRequest,\n  options: { resource: string },\n): AsyncIterable<T> {\n  let req: HttpRequest = initial;\n  while (true) {\n    const res = await request(req, { resource: options.resource });\n    const { items, nextCursor } = parse(res.body);\n    for (const item of items) {\n      yield item;\n    }\n    if (!nextCursor) {\n      return;\n    }\n    req = buildNext(req, nextCursor);\n  }\n}\n\nexport async function* paginatePage<T>(\n  initial: HttpRequest,\n  parse: (body: unknown) => { items: T[]; hasMore: boolean },\n  buildPage: (req: HttpRequest, page: number) => HttpRequest,\n  options: { resource: string },\n): AsyncIterable<T> {\n  let page = 1;\n  while (true) {\n    const req = page === 1 ? initial : buildPage(initial, page);\n    const res = await request(req, { resource: options.resource });\n    const { items, hasMore } = parse(res.body);\n    for (const item of items) {\n      yield item;\n    }\n    if (!hasMore || items.length === 0) {\n      return;\n    }\n    page++;\n  }\n}\n","export type LogFields = Record<string, unknown>;\n\nexport interface ConnectorLogger {\n  info(event: string, fields?: LogFields): void;\n  warn(event: string, fields?: LogFields): void;\n}\n\nexport interface ConnectorLoggerOptions {\n  scope: string;\n}\n\nconst MAX_VALUE_LEN = 120;\n\nfunction truncate(s: string, max = MAX_VALUE_LEN): string {\n  if (s.length <= max) {\n    return s;\n  }\n  return `${s.slice(0, max - 1)}…`;\n}\n\nfunction formatValue(value: unknown): string {\n  if (value === null) {\n    return 'null';\n  }\n  if (value === undefined) {\n    return '';\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (typeof value === 'string') {\n    const t = truncate(value);\n    if (/[\\s\"=]/.test(t)) {\n      return JSON.stringify(t);\n    }\n    return t;\n  }\n  if (typeof value === 'bigint') {\n    return value.toString();\n  }\n  let json: string | undefined;\n  try {\n    json = JSON.stringify(value);\n  } catch {\n    json = undefined;\n  }\n  return truncate(json ?? String(value));\n}\n\nexport function formatLogFields(fields?: LogFields): string {\n  if (!fields) {\n    return '';\n  }\n  const parts: string[] = [];\n  for (const [k, v] of Object.entries(fields)) {\n    if (v === undefined) {\n      continue;\n    }\n    parts.push(`${k}=${formatValue(v)}`);\n  }\n  return parts.length > 0 ? ` ${parts.join(' ')}` : '';\n}\n\nexport function formatLogLine(\n  scope: string,\n  event: string,\n  fields?: LogFields,\n): string {\n  return `[${scope}] ${event}${formatLogFields(fields)}`;\n}\n\nexport function createDefaultConnectorLogger(\n  opts: ConnectorLoggerOptions,\n): ConnectorLogger {\n  return {\n    info(event, fields) {\n      console.info(formatLogLine(opts.scope, event, fields));\n    },\n    warn(event, fields) {\n      console.warn(formatLogLine(opts.scope, event, fields));\n    },\n  };\n}\n\nconst NOOP_LOGGER: ConnectorLogger = {\n  info() {},\n  warn() {},\n};\n\nexport function noopConnectorLogger(): ConnectorLogger {\n  return NOOP_LOGGER;\n}\n","import {\n  buildServiceAccountJwt,\n  gcpAuthConfigShape,\n  tokenResponseSchema,\n} from '@rawdash/connector-gcp-shared';\nimport {\n  AuthError,\n  connectorUserAgent,\n  parseEpoch,\n} from '@rawdash/connector-shared';\nimport {\n  BaseConnector,\n  type ConnectorContext,\n  type ConnectorDoc,\n  type CredentialsSchema,\n  type JSONValue,\n  type MetricSample,\n  type StorageHandle,\n  type SyncOptions,\n  type SyncResult,\n  defineConfigFields,\n  defineConnectorDoc,\n  defineResources,\n  schemasFromResources,\n} from '@rawdash/core';\nimport { z } from 'zod';\n\n// ---------------------------------------------------------------------------\n// Config\n// ---------------------------------------------------------------------------\n\nconst metricQuerySchema = z.object({\n  id: z\n    .string()\n    .regex(\n      /^[a-z][a-zA-Z0-9_]*$/,\n      'Monitoring query id must start with a lowercase letter and contain only letters, digits, and underscores',\n    ),\n  metricType: z.string().min(1).meta({\n    description:\n      'Fully-qualified Cloud Monitoring metric type, e.g. compute.googleapis.com/instance/cpu/utilization.',\n  }),\n  filter: z.string().optional().meta({\n    description:\n      'Optional additional filter combined with metric.type using AND, e.g. resource.labels.zone=\"us-central1-a\".',\n  }),\n  alignmentPeriod: z\n    .string()\n    .regex(\n      /^\\d+s$/,\n      'alignmentPeriod must be a duration in seconds, e.g. 60s or 300s',\n    )\n    .meta({\n      description:\n        'Aggregation alignment period as a duration in seconds, e.g. 300s.',\n    }),\n  perSeriesAligner: z\n    .enum([\n      'ALIGN_NONE',\n      'ALIGN_DELTA',\n      'ALIGN_RATE',\n      'ALIGN_INTERPOLATE',\n      'ALIGN_NEXT_OLDER',\n      'ALIGN_MIN',\n      'ALIGN_MAX',\n      'ALIGN_MEAN',\n      'ALIGN_COUNT',\n      'ALIGN_SUM',\n      'ALIGN_STDDEV',\n      'ALIGN_COUNT_TRUE',\n      'ALIGN_COUNT_FALSE',\n      'ALIGN_FRACTION_TRUE',\n      'ALIGN_PERCENTILE_99',\n      'ALIGN_PERCENTILE_95',\n      'ALIGN_PERCENTILE_50',\n      'ALIGN_PERCENTILE_05',\n      'ALIGN_PERCENT_CHANGE',\n    ])\n    .meta({\n      description:\n        'Cloud Monitoring perSeriesAligner statistic, e.g. ALIGN_MEAN, ALIGN_SUM, ALIGN_PERCENTILE_99.',\n    }),\n});\n\nexport const configFields = defineConfigFields(\n  z\n    .object({\n      projectId: z.string().min(1).meta({\n        label: 'GCP project ID',\n        description:\n          'Google Cloud project ID whose metrics should be synced (the project that owns the monitored resources).',\n        placeholder: 'my-project-123',\n      }),\n      ...gcpAuthConfigShape,\n      metricQueries: z.array(metricQuerySchema).nonempty().meta({\n        label: 'Metric queries',\n        description:\n          'Cloud Monitoring is too broad to mirror wholesale; declare the specific metrics to pull. Each query needs an id, metric type, alignment period (e.g. 300s), and a perSeriesAligner statistic, with an optional filter on resource labels.',\n      }),\n      lookbackMinutes: z.number().int().positive().max(40_320).optional().meta({\n        label: 'Lookback (minutes)',\n        description:\n          'How far back to pull data points on a full sync when the host does not supply a since bound. Defaults to 180.',\n        placeholder: '180',\n      }),\n    })\n    .refine(\n      (cfg) =>\n        new Set(cfg.metricQueries.map((q) => q.id)).size ===\n        cfg.metricQueries.length,\n      {\n        path: ['metricQueries'],\n        message: 'Each metric query id must be unique',\n      },\n    ),\n);\n\nexport const doc: ConnectorDoc = defineConnectorDoc({\n  displayName: 'Google Cloud Monitoring',\n  category: 'infrastructure',\n  brandColor: '#4285F4',\n  tagline:\n    'Pull declared Cloud Monitoring metric time series (any metric type, aligner, and period) into a single metric series per query.',\n  rateLimit:\n    'Cloud Monitoring projects.timeSeries.list is rate-limited per project; 429 / RESOURCE_EXHAUSTED responses are retried with backoff. Pagination uses nextPageToken.',\n  vendor: {\n    name: 'Google Cloud',\n    apiDocs: 'https://cloud.google.com/monitoring/api/v3',\n    website: 'https://cloud.google.com/monitoring',\n  },\n  auth: {\n    summary:\n      'Authenticate against the Cloud Monitoring v3 API with a Google service account JSON key. The service account needs the Monitoring Viewer role (roles/monitoring.viewer) on the project whose metrics it reads.',\n    setup: [\n      'Identify the GCP project whose metrics you want to sync.',\n      'Create a service account at Google Cloud -> IAM & Admin -> Service Accounts in that project (or grant an existing one access).',\n      'Grant the service account the Monitoring Viewer role (roles/monitoring.viewer) on the project. The API enables this role automatically for owners and editors.',\n      'Generate a JSON key for the service account and store its contents as a secret (e.g. GCP_MONITORING_SA_JSON).',\n      'Reference the key from config as serviceAccountJson: secret(\"GCP_MONITORING_SA_JSON\") and set projectId to the same project.',\n    ],\n  },\n  limitations: [\n    'Cloud Monitoring is too broad to mirror wholesale; only the metrics declared in metricQueries are synced; there is no automatic metric discovery.',\n    'The series name is derived from the metric type, so two queries against the same metricType with different aligners or filters share one series name and are distinguished only by sample attributes.',\n    'Each query alignmentPeriod must be expressed as a duration in seconds, e.g. 60s or 300s.',\n    'A full sync uses lookbackMinutes; a latest sync uses a short window covering the last few alignment periods.',\n    'Distribution-valued metrics (e.g. latency histograms) require a perSeriesAligner that reduces them to a scalar (ALIGN_PERCENTILE_99, ALIGN_MEAN, etc.); raw distributions are not stored.',\n  ],\n});\n\n// ---------------------------------------------------------------------------\n// Settings / credentials\n// ---------------------------------------------------------------------------\n\nexport interface GcpMonitoringMetricQuery {\n  id: string;\n  metricType: string;\n  filter?: string;\n  alignmentPeriod: string;\n  perSeriesAligner: string;\n}\n\nexport interface GcpMonitoringSettings {\n  projectId: string;\n  metricQueries: GcpMonitoringMetricQuery[];\n  lookbackMinutes?: number;\n}\n\nconst gcpMonitoringCredentials = {\n  serviceAccountJson: {\n    description: 'Google service account JSON key (raw JSON or base64)',\n    auth: 'required' as const,\n  },\n} satisfies CredentialsSchema;\n\ntype GcpMonitoringCredentials = typeof gcpMonitoringCredentials;\n\n// ---------------------------------------------------------------------------\n// Cloud Monitoring v3 response schemas\n// ---------------------------------------------------------------------------\n\nconst int64String = z.string().regex(/^-?\\d+$/);\nconst isoTimestamp = z.iso.datetime();\n\nconst pointValue = z\n  .object({\n    doubleValue: z.number().optional(),\n    int64Value: int64String.optional(),\n    boolValue: z.boolean().optional(),\n    stringValue: z.string().optional(),\n    distributionValue: z.unknown().optional(),\n  })\n  .refine(\n    (v) =>\n      v.doubleValue !== undefined ||\n      v.int64Value !== undefined ||\n      v.boolValue !== undefined ||\n      v.stringValue !== undefined ||\n      v.distributionValue !== undefined,\n    {\n      message: 'point value must carry at least one supported value field',\n    },\n  );\n\nconst pointSchema = z.object({\n  interval: z.object({\n    startTime: isoTimestamp.optional(),\n    endTime: isoTimestamp,\n  }),\n  value: pointValue,\n});\n\nconst timeSeriesSchema = z.object({\n  metric: z.object({\n    type: z.string(),\n    labels: z.record(z.string(), z.string()).optional(),\n  }),\n  resource: z\n    .object({\n      type: z.string().optional(),\n      labels: z.record(z.string(), z.string()).optional(),\n    })\n    .optional(),\n  valueType: z.string().optional(),\n  metricKind: z.string().optional(),\n  points: z.array(pointSchema).optional(),\n});\n\nconst listTimeSeriesResponseSchema = z.object({\n  timeSeries: z.array(timeSeriesSchema).optional(),\n  nextPageToken: z.string().optional(),\n});\n\n// ---------------------------------------------------------------------------\n// Resources\n// ---------------------------------------------------------------------------\n\nexport const gcpMonitoringResources = defineResources({\n  '<metricType>': {\n    shape: 'metric',\n    dynamic: true,\n    description:\n      'One metric series per declared metric query. The series name is the configured metric type (e.g. `compute.googleapis.com/instance/cpu/utilization`), so the actual keys depend on the configured `metricQueries`. Each sample carries the aligner, alignment period, query id, and metric/resource labels as attributes.',\n    endpoint: 'GET /v3/projects/{projectId}/timeSeries',\n    granularity: 'Per alignmentPeriod (a duration in seconds, e.g. 300s)',\n    notes:\n      'Each sync replaces the full set of samples for the metric names it owns (idempotent). Distribution-valued points are dropped unless reduced to a scalar by the perSeriesAligner.',\n    dimensions: [\n      {\n        name: 'perSeriesAligner',\n        description:\n          'The Cloud Monitoring statistic requested for the query, e.g. ALIGN_MEAN, ALIGN_SUM, or ALIGN_PERCENTILE_99.',\n      },\n      {\n        name: 'alignmentPeriod',\n        description:\n          'The aggregation alignment period as configured, e.g. 300s.',\n      },\n      {\n        name: 'queryId',\n        description:\n          'The configured id of the metric query that produced the sample.',\n      },\n      {\n        name: 'resourceType',\n        description:\n          'The monitored resource type the sample originated from (e.g. gce_instance).',\n      },\n    ],\n    responses: {\n      oauth_token: tokenResponseSchema,\n      time_series: listTimeSeriesResponseSchema,\n    },\n  },\n});\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\nconst MONITORING_API_BASE = 'https://monitoring.googleapis.com/v3';\nconst MONITORING_SCOPE = 'https://www.googleapis.com/auth/monitoring.read';\nconst PAGE_SIZE = 1000;\nconst DEFAULT_LOOKBACK_MINUTES = 180;\nconst MS_PER_MINUTE = 60_000;\n\nexport const id = 'gcp-monitoring';\n\n// ---------------------------------------------------------------------------\n// GcpMonitoringConnector\n// ---------------------------------------------------------------------------\n\nexport class GcpMonitoringConnector extends BaseConnector<\n  GcpMonitoringSettings,\n  GcpMonitoringCredentials\n> {\n  static readonly id = id;\n\n  static readonly resources = gcpMonitoringResources;\n\n  static readonly schemas = schemasFromResources(gcpMonitoringResources);\n\n  static create(\n    input: unknown,\n    ctx?: ConnectorContext,\n  ): GcpMonitoringConnector {\n    const parsed = configFields.parse(input);\n    return new GcpMonitoringConnector(\n      {\n        projectId: parsed.projectId,\n        metricQueries: parsed.metricQueries,\n        lookbackMinutes: parsed.lookbackMinutes,\n      },\n      {\n        serviceAccountJson: parsed.serviceAccountJson,\n      },\n      ctx,\n    );\n  }\n\n  readonly id = id;\n  override readonly credentials = gcpMonitoringCredentials;\n\n  private cachedToken: { token: string; expiresAt: number } | null = null;\n\n  private async getAccessToken(signal?: AbortSignal): Promise<string> {\n    if (this.cachedToken && Date.now() < this.cachedToken.expiresAt) {\n      return this.cachedToken.token;\n    }\n    const { serviceAccountJson } = this.creds;\n    if (!serviceAccountJson) {\n      throw new AuthError(`${this.id}: missing serviceAccountJson credential`);\n    }\n    const { url, body } = await buildServiceAccountJwt(\n      serviceAccountJson,\n      MONITORING_SCOPE,\n    );\n    const res = await this.post<{\n      access_token: string;\n      expires_in?: number;\n    }>(url, {\n      resource: 'oauth_token',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body,\n      signal,\n    });\n    const expiresIn = res.body.expires_in ?? 3600;\n    this.cachedToken = {\n      token: res.body.access_token,\n      expiresAt: Date.now() + (expiresIn - 60) * 1000,\n    };\n    return this.cachedToken.token;\n  }\n\n  private computeWindow(options: SyncOptions): {\n    startMs: number;\n    endMs: number;\n  } {\n    const endMs = Date.now();\n    if (options.since) {\n      const sinceMs = parseEpoch(options.since, 'iso');\n      if (sinceMs !== null) {\n        return { startMs: Math.min(sinceMs, endMs), endMs };\n      }\n    }\n    if (options.mode === 'latest') {\n      const maxPeriodSec = Math.max(\n        ...this.settings.metricQueries.map(\n          (q) => parseDurationSeconds(q.alignmentPeriod) ?? 60,\n        ),\n        60,\n      );\n      return { startMs: endMs - maxPeriodSec * 3 * 1000, endMs };\n    }\n    const lookback = this.settings.lookbackMinutes ?? DEFAULT_LOOKBACK_MINUTES;\n    return { startMs: endMs - lookback * MS_PER_MINUTE, endMs };\n  }\n\n  private buildFilter(query: GcpMonitoringMetricQuery): string {\n    const base = `metric.type = \"${query.metricType}\"`;\n    if (query.filter && query.filter.trim().length > 0) {\n      return `${base} AND ${query.filter}`;\n    }\n    return base;\n  }\n\n  private async listTimeSeries(\n    accessToken: string,\n    query: GcpMonitoringMetricQuery,\n    startMs: number,\n    endMs: number,\n    pageToken: string | undefined,\n    signal?: AbortSignal,\n  ): Promise<z.infer<typeof listTimeSeriesResponseSchema>> {\n    const params = new URLSearchParams();\n    params.set('filter', this.buildFilter(query));\n    params.set('interval.startTime', new Date(startMs).toISOString());\n    params.set('interval.endTime', new Date(endMs).toISOString());\n    params.set('aggregation.alignmentPeriod', query.alignmentPeriod);\n    params.set('aggregation.perSeriesAligner', query.perSeriesAligner);\n    params.set('pageSize', String(PAGE_SIZE));\n    if (pageToken !== undefined) {\n      params.set('pageToken', pageToken);\n    }\n\n    const url = `${MONITORING_API_BASE}/projects/${encodeURIComponent(\n      this.settings.projectId,\n    )}/timeSeries?${params.toString()}`;\n\n    const res = await this.get<z.infer<typeof listTimeSeriesResponseSchema>>(\n      url,\n      {\n        resource: 'time_series',\n        headers: {\n          Authorization: `Bearer ${accessToken}`,\n          'User-Agent': connectorUserAgent(this.id),\n        },\n        signal,\n      },\n    );\n    return res.body;\n  }\n\n  async sync(\n    options: SyncOptions,\n    storage: StorageHandle,\n    signal?: AbortSignal,\n  ): Promise<SyncResult> {\n    const queries = this.settings.metricQueries;\n    if (queries.length === 0) {\n      return { done: true };\n    }\n\n    const names = new Set(queries.map((q) => q.metricType));\n    const { startMs, endMs } = this.computeWindow(options);\n\n    let token: string | null = null;\n    const getToken = async (sig?: AbortSignal): Promise<string> => {\n      if (token === null) {\n        token = await this.getAccessToken(sig);\n      }\n      return token;\n    };\n\n    const samples: MetricSample[] = [];\n\n    for (const query of queries) {\n      let pageToken: string | undefined;\n      let page = 0;\n      let pageItems = 0;\n      let total = 0;\n      const phaseStart = Date.now();\n      do {\n        if (signal?.aborted) {\n          return { done: false };\n        }\n        let response: z.infer<typeof listTimeSeriesResponseSchema>;\n        try {\n          const accessToken = await getToken(signal);\n          response = await this.listTimeSeries(\n            accessToken,\n            query,\n            startMs,\n            endMs,\n            pageToken,\n            signal,\n          );\n        } catch (err) {\n          this.logger.warn('fetch page failed', {\n            resource: query.metricType,\n            page: page + 1,\n            queryId: query.id,\n            error: err instanceof Error ? err.message : String(err),\n          });\n          throw err;\n        }\n        const series = response.timeSeries ?? [];\n        pageItems = 0;\n        for (const ts of series) {\n          for (const point of ts.points ?? []) {\n            const sample = pointToSample(query, ts, point);\n            if (sample !== null) {\n              samples.push(sample);\n              pageItems += 1;\n            }\n          }\n        }\n        total += pageItems;\n        pageToken =\n          typeof response.nextPageToken === 'string' &&\n          response.nextPageToken.length > 0\n            ? response.nextPageToken\n            : undefined;\n        page += 1;\n        this.logger.info('fetched page', {\n          resource: query.metricType,\n          queryId: query.id,\n          page,\n          items: pageItems,\n          next: pageToken ?? null,\n        });\n      } while (pageToken !== undefined);\n      this.logger.info('resource done', {\n        resource: query.metricType,\n        queryId: query.id,\n        pages: page,\n        items: total,\n        duration_ms: Date.now() - phaseStart,\n      });\n    }\n\n    await storage.metrics(samples, { names: [...names] });\n    return { done: true };\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Helpers (exported for tests)\n// ---------------------------------------------------------------------------\n\nexport function parseDurationSeconds(duration: string): number | null {\n  const m = /^(\\d+)s$/.exec(duration);\n  if (!m) {\n    return null;\n  }\n  const n = Number.parseInt(m[1]!, 10);\n  return Number.isFinite(n) ? n : null;\n}\n\nexport function pointToSample(\n  query: GcpMonitoringMetricQuery,\n  series: z.infer<typeof timeSeriesSchema>,\n  point: z.infer<typeof pointSchema>,\n): MetricSample | null {\n  const tsIso = point.interval.endTime;\n  const ts = parseEpoch(tsIso, 'iso');\n  if (ts === null) {\n    return null;\n  }\n  const value = extractScalarValue(point.value);\n  if (value === null) {\n    return null;\n  }\n  const attributes: Record<string, JSONValue> = {\n    perSeriesAligner: query.perSeriesAligner,\n    alignmentPeriod: query.alignmentPeriod,\n    queryId: query.id,\n  };\n  if (series.resource?.type) {\n    attributes['resourceType'] = series.resource.type;\n  }\n  for (const [k, v] of Object.entries(series.metric.labels ?? {})) {\n    attributes[`metric.${k}`] = v;\n  }\n  for (const [k, v] of Object.entries(series.resource?.labels ?? {})) {\n    attributes[`resource.${k}`] = v;\n  }\n  return { name: query.metricType, ts, value, attributes };\n}\n\nfunction extractScalarValue(v: z.infer<typeof pointValue>): number | null {\n  if (v.doubleValue !== undefined && Number.isFinite(v.doubleValue)) {\n    return v.doubleValue;\n  }\n  if (v.int64Value !== undefined) {\n    const n = Number(v.int64Value);\n    return Number.isSafeInteger(n) ? n : null;\n  }\n  if (v.boolValue !== undefined) {\n    return v.boolValue ? 1 : 0;\n  }\n  // stringValue and distributionValue are not scalar; drop them silently. The\n  // resource doc calls this out explicitly so users know to pick an aligner\n  // that reduces distributions (e.g. ALIGN_PERCENTILE_99) when needed.\n  return null;\n}\n","import { GcpMonitoringConnector } from './gcp-monitoring';\n\nexport {\n  GcpMonitoringConnector,\n  configFields,\n  doc,\n  id,\n  parseDurationSeconds,\n  pointToSample,\n  gcpMonitoringResources as resources,\n} from './gcp-monitoring';\nexport type {\n  GcpMonitoringMetricQuery,\n  GcpMonitoringSettings,\n} from './gcp-monitoring';\nexport default GcpMonitoringConnector;\n"],"mappings":"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","names":["z","z"]}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@rawdash/connector-gcp-monitoring",
+  "version": "0.0.1",
+  "description": "Rawdash connector for Google Cloud Monitoring — syncs declared metric time series via the Cloud Monitoring v3 API into the six-shape storage model",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rawdash/rawdash.git",
+    "directory": "packages/connectors/gcp-monitoring"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "@rawdash/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@rawdash/core": "workspace:*",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@rawdash/connector-gcp-shared": "workspace:*",
+    "@rawdash/connector-shared": "workspace:*",
+    "@rawdash/connector-test-utils": "workspace:*",
+    "fast-check": "^4.8.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.2",
+    "vitest": "^4.1.4"
+  }
+}