typekro 0.33.9 → 0.34.0

package/dist/factories/clickstack/utils/storage.d.ts

@@ -0,0 +1,449 @@
+/**
+ * ClickStack storage consumption: TTL retention and the collector's
+ * persistent sending queue.
+ *
+ * The storage POLICY needs nothing here. The `clickhouse` factory sets
+ * `merge_tree/storage_policy` as the server default, so the gateway
+ * collector's goose migrations create `otel_logs` / `otel_traces` /
+ * `otel_metrics_*` / `hyperdx_sessions` on the S3 policy with no
+ * `SETTINGS storage_policy` clause and no per-table DDL from TypeKro. This
+ * module covers the two things a server default cannot express:
+ *
+ * 1. **Retention** — `TTL toDateTime(<timestamp>) + INTERVAL n UNIT DELETE`,
+ *    applied by an idempotent CronJob because the tables do not exist until the
+ *    collector has migrated, and because TypeKro does not own their DDL.
+ *    LIVE-VERIFIED: the collector's own migration already sets a 30-day TTL
+ *    (`toDateTime(Timestamp) + toIntervalDay(30)` with `ttl_only_drop_parts`),
+ *    so `retention` OVERRIDES that default rather than establishing the first
+ *    one — which is exactly why the idempotence probe compares the COMPLETE
+ *    TTL clause rather than merely asking whether a TTL exists.
+ * 2. **Persistent queue** — a `file_storage`-backed exporter queue so a
+ *    ClickHouse restart (which is exactly what an S3-backed node rebuild
+ *    causes) does not drop in-flight telemetry. Its directory is backed by a
+ *    STANDALONE PersistentVolumeClaim owned by the composition: an `emptyDir`
+ *    or a generic ephemeral volume is deleted with the collector Pod, so
+ *    neither survives the collector restart the queue exists to survive.
+ *
+ * S3_PLAIN_REWRITABLE NOTE: retention and that disk type are MUTUALLY
+ * EXCLUSIVE, and `resolveClickStackStorage` rejects the combination.
+ * `MODIFY TTL` normally schedules a materialization MUTATION, which
+ * plain_rewritable does not support — every statement this module emits
+ * therefore carries `SETTINGS materialize_ttl_after_modify = 0` so expiry
+ * happens during merges instead. LIVE-VERIFIED (ClickHouse 25.7) that this is
+ * not enough: the immutable metadata type refuses the metadata ALTER itself
+ * ("ALTER TABLE commands are not supported on immutable disk", code 344), and
+ * the identical statement succeeds against a table on the server's local
+ * policy. The setting is kept for the `diskType: 's3'` path, where the
+ * materialization pass is the only thing worth skipping.
+ */
+import type { ClickStackStorageOptions } from '../types.js';
+import { type CollectorConfigFragment } from './collector-config.js';
+/** Default cron schedule for the retention DDL CronJob. */
+export declare const DEFAULT_RETENTION_SCHEDULE = "17 * * * *";
+/**
+ * Default image for the retention DDL CronJob. The ClickStack chart vendors
+ * ClickHouse 25.7, so the matching server image supplies a compatible
+ * `clickhouse-client`.
+ */
+export declare const DEFAULT_RETENTION_IMAGE = "clickhouse/clickhouse-server:25.7";
+/** Default persistent-queue directory inside the collector pod. */
+export declare const DEFAULT_QUEUE_DIRECTORY = "/var/lib/otelcol/file_storage";
+/** Default `file_storage` extension instance name. */
+export declare const QUEUE_EXTENSION_NAME = "file_storage/hyperdx";
+/**
+ * Default exporters whose `sending_queue` is switched to file storage.
+ *
+ * The ClickStack collector defines a single ClickHouse exporter, `clickhouse`,
+ * and all three signal pipelines export through it. A name that is NOT one the
+ * agent defines fails silently: the supervisor merges the overlay, the
+ * `exporters` map simply grows an exporter no pipeline uses, and the real one
+ * keeps its in-memory queue. That is why the integration suite asserts these
+ * names against the agent's own EFFECTIVE configuration instead of trusting
+ * the default.
+ */
+export declare const DEFAULT_QUEUE_EXPORTER_NAMES: readonly ["clickhouse"];
+/**
+ * Default `service.extensions` list emitted with the queue overlay.
+ *
+ * A YAML list in `global.otelCollector.customConfig` REPLACES the supervisor's
+ * own list, so this must name every extension the collector needs — see the
+ * warning on {@link ClickStackPersistentQueueOptions}.
+ */
+export declare const DEFAULT_QUEUE_EXTENSIONS: readonly ["health_check", "file_storage/hyperdx"];
+/** Volume name used for the persistent-queue directory. */
+export declare const QUEUE_VOLUME_NAME = "otel-file-storage";
+/**
+ * Deployment update strategy forced on the gateway whenever the queue is on.
+ *
+ * The collector chart's `rollout.strategy` (default `RollingUpdate`) becomes
+ * the Deployment's `spec.strategy.type` verbatim. `Recreate` is the only value
+ * under which a rollout terminates the old collector BEFORE creating its
+ * replacement, which is what a single-writer queue on a ReadWriteOnce claim
+ * requires — see {@link renderPersistentQueueValues} for why the replica pin
+ * does not cover this on its own.
+ */
+export declare const QUEUE_ROLLOUT_STRATEGY = "Recreate";
+/**
+ * The gateway subchart's OWN `extraVolumes` entry, which we must re-emit.
+ *
+ * Helm REPLACES a list-valued override rather than appending to it, and the
+ * chart mounts the ConfigMap rendered from `global.otelCollector.customConfig`
+ * through exactly these two lists. Chart 3.2.0's `values.yaml` says so in a
+ * comment on the defaults:
+ *
+ *   "NOTE: if you override extraVolumes/extraVolumeMounts yourself, Helm
+ *    replaces these lists entirely -- re-include the entries below to keep
+ *    global.otelCollector.customConfig working."
+ *
+ * LIVE-VERIFIED what happens when you don't: the queue volume alone evicts the
+ * custom-config mount, the OpAMP supervisor logs `Could not read local config
+ * file: open /etc/otelcol-contrib/custom/custom.config.yaml: no such file or
+ * directory` on every poll, never composes a merged agent config, and the
+ * collector never starts its OTLP receivers — while the Pod still reports
+ * Ready, because readiness comes from the SUPERVISOR's health_check and not
+ * from the agent. Enabling the persistent queue would silently take the whole
+ * gateway down.
+ */
+export declare const CHART_CUSTOM_CONFIG_VOLUME_NAME = "custom-config";
+/** ConfigMap the chart renders `global.otelCollector.customConfig` into. */
+export declare const CHART_CUSTOM_CONFIG_CONFIG_MAP_NAME = "clickstack-otel-custom-config";
+/** Directory the chart mounts {@link CHART_CUSTOM_CONFIG_CONFIG_MAP_NAME} at. */
+export declare const CHART_CUSTOM_CONFIG_MOUNT_PATH = "/etc/otelcol-contrib/custom";
+/** Default size of the persistent-queue PersistentVolumeClaim. */
+export declare const DEFAULT_QUEUE_SIZE = "10Gi";
+/**
+ * Access modes of the persistent-queue PersistentVolumeClaim — not an option.
+ *
+ * `ReadWriteMany` used to be selectable, on the theory that a shared volume
+ * would let several collector replicas run off one queue directory. It does
+ * not, and the volume was never the binding constraint: the OTel `file_storage`
+ * extension stores the queue in a bbolt database, and bbolt takes an EXCLUSIVE
+ * FILE LOCK on open (the extension's own README says a single collector
+ * instance per directory; collector-contrib issue #5894 is the second instance
+ * hanging on that lock). Two replicas pointed at one directory therefore either
+ * block forever or, if the lock is lost across a node boundary the way a
+ * network filesystem can lose it, corrupt the database. Offering RWX advertised
+ * a multi-replica queue that cannot exist, so the knob is gone and the claim is
+ * always `ReadWriteOnce`.
+ */
+export declare const QUEUE_ACCESS_MODES: readonly ["ReadWriteOnce"];
+/** Name suffix of the queue PersistentVolumeClaim (and its resource id). */
+export declare const QUEUE_CLAIM_NAME_SUFFIX = "-otel-queue";
+/**
+ * Name of the queue PersistentVolumeClaim for a release.
+ *
+ * Shared by the composition (which CREATES the claim) and the values mapper
+ * (which MOUNTS it by `claimName`), so the two cannot drift. Accepts a schema
+ * reference for `name` the same way every other name in this family does — the
+ * template literal serializes to CEL in KRO mode.
+ *
+ * @param releaseName - Helm release name (`spec.name`)
+ * @returns The claim name
+ */
+export declare function clickStackQueueClaimName(releaseName: string): string;
+/** ConfigMap the ClickStack chart renders the shared non-secret env into. */
+export declare const CLICKSTACK_CONFIG_MAP_NAME = "clickstack-config";
+/** Secret the ClickStack chart renders the shared secret env into. */
+export declare const CLICKSTACK_SECRET_NAME = "clickstack-secret";
+/** One OTel table and the column its TTL is expressed against. */
+export interface ClickStackRetentionTable {
+    /** Table name as created by the gateway collector's goose migrations. */
+    readonly table: string;
+    /** Timestamp column the TTL is expressed against. */
+    readonly column: string;
+}
+/**
+ * Tables per signal, with the timestamp column each one's TTL keys off.
+ *
+ * Columns mirror the `defaultSources` the values mapper emits (which mirror
+ * the chart's own defaults), so they track the schema HyperDX queries:
+ * `Timestamp` for logs/traces, `TimeUnix` for metrics, `TimestampTime` for
+ * sessions.
+ */
+export declare const CLICKSTACK_RETENTION_TABLES: Readonly<Record<'logs' | 'traces' | 'metrics', readonly ClickStackRetentionTable[]>>;
+/** A retention duration parsed into a ClickHouse `INTERVAL`. */
+export interface ParsedRetention {
+    readonly amount: number;
+    readonly unit: 'MINUTE' | 'HOUR' | 'DAY';
+}
+/**
+ * Parse a retention duration string into a ClickHouse `INTERVAL`.
+ *
+ * @param context - Entry point name for the error message
+ * @param field - Offending field path (e.g. `storage.retention.logs`)
+ * @param value - Duration string such as `'30d'`, `'720h'`, or `'90m'`
+ * @returns The parsed amount and `INTERVAL` unit
+ * @throws Error when the duration cannot be parsed or is not positive
+ */
+export declare function parseRetentionDuration(context: string, field: string, value: string): ParsedRetention;
+/** One resolved retention entry: which table, and the TTL expression for it. */
+export interface ResolvedRetentionEntry extends ClickStackRetentionTable {
+    readonly signal: 'logs' | 'traces' | 'metrics';
+    readonly duration: string;
+    /** The `MODIFY TTL` expression to apply. */
+    readonly ttlExpression: string;
+    /**
+     * COMPLETE normalized TTL clauses that mean "the intended TTL is already
+     * applied" — matched by EQUALITY, never by substring.
+     *
+     * WHY EQUALITY: a substring probe is wrong in both directions. Looking for
+     * `toIntervalDay(3)` matches a table that actually carries
+     * `toIntervalDay(30)`, so a needed change is skipped; and a table carrying
+     * the intended interval plus extra clauses (`… + toIntervalDay(30) WHERE
+     * …`, or a second `TO VOLUME` entry) also matches, so a DIFFERENT retention
+     * policy is reported as converged. Comparing the whole clause makes both
+     * cases mismatches, which is the correct answer.
+     *
+     * TWO SPELLINGS: ClickHouse re-renders a stored TTL from its AST, so the
+     * text that comes back is not the text that went in — `INTERVAL 30 DAY`
+     * renders as `toIntervalDay(30)`, and the default `DELETE` action is not
+     * rendered at all. The AST form is what a live server returns
+     * (LIVE-VERIFIED); the source spelling is kept as a second accepted value so
+     * the probe does not degrade into "re-ALTER on every run" if a release
+     * renders the clause verbatim.
+     */
+    readonly ttlRenderings: readonly string[];
+}
+/**
+ * Collapse a TTL clause read back from ClickHouse into its comparable form.
+ *
+ * The server's own rendering is already canonical apart from whitespace, so
+ * this only collapses runs of blanks and trims — enough to compare clauses
+ * across formatting differences without pretending to normalize SQL.
+ *
+ * @param rendered - A TTL clause as extracted from `engine_full`
+ * @returns The clause with whitespace runs collapsed to single spaces
+ */
+export declare function normalizeRenderedTtl(rendered: string): string;
+/**
+ * Whether a TTL clause read back from a live table already expresses the
+ * intended retention.
+ *
+ * This is the exact predicate the rendered CronJob script implements in shell
+ * (an equality test against {@link ResolvedRetentionEntry.ttlRenderings}); it
+ * exists as a function so the comparison semantics — in particular the
+ * near-miss cases a substring probe gets wrong — are directly testable.
+ *
+ * @param currentClause - TTL clause extracted from `system.tables.engine_full`
+ * @param entry - The resolved retention entry being converged
+ * @returns True when no `MODIFY TTL` is needed
+ */
+export declare function ttlAlreadyApplied(currentClause: string, entry: ResolvedRetentionEntry): boolean;
+/** Fully defaulted, validated ClickStack storage consumption options. */
+export interface ResolvedClickStackStorage {
+    readonly mode: 'pvc' | 's3';
+    readonly diskType?: 's3' | 's3_plain_rewritable';
+    readonly policyName?: string;
+    readonly retention?: {
+        readonly logs?: string;
+        readonly traces?: string;
+        readonly metrics?: string;
+    };
+    readonly retentionEntries: readonly ResolvedRetentionEntry[];
+    readonly retentionSchedule: string;
+    readonly retentionImage: string;
+    readonly persistentQueue?: {
+        readonly directory: string;
+        /** PVC size — always present: there is no ephemeral fallback. */
+        readonly size: string;
+        readonly storageClassName?: string;
+        /** Always {@link QUEUE_ACCESS_MODES} — see the constant for why. */
+        readonly accessModes: readonly string[];
+        /** Always non-empty — `resolveClickStackStorage` rejects an empty list. */
+        readonly exporterNames: readonly string[];
+        readonly extensions: readonly string[];
+    };
+}
+/**
+ * Resolve and validate the build-time storage options.
+ *
+ * @param context - Entry point name for every error message
+ * @param options - Build-time storage options (omit for the PVC default)
+ * @returns The resolved options, with retention expanded per table
+ * @throws Error when a retention duration is unparseable, when an
+ *   S3-specific option is set on the PVC default, or when a queue component
+ *   name is an object-model member (see {@link assertQueueComponentNames})
+ */
+export declare function resolveClickStackStorage(context: string, options: ClickStackStorageOptions | undefined): ResolvedClickStackStorage;
+/**
+ * Reject more than one gateway collector replica alongside a persistent queue.
+ *
+ * UNCONDITIONAL: `persistentQueue` means exactly one collector replica, and no
+ * volume choice changes that. The `file_storage` extension keeps the queue in a
+ * bbolt database, and bbolt takes an EXCLUSIVE FILE LOCK for the lifetime of
+ * the handle — the extension's README is explicit that one directory serves one
+ * collector instance, and collector-contrib issue #5894 is the report of the
+ * second instance hanging on that lock. So a second replica either blocks
+ * forever on `Open` or, where the lock does not hold across a node boundary,
+ * writes the same pages as the first.
+ *
+ * The claim's `ReadWriteOnce` mode is a second, weaker line of defence (extra
+ * Pods on other nodes stay `Pending` on `Multi-Attach`), not the reason.
+ * `ReadWriteMany` was previously accepted as a way to lift this guard; it is
+ * gone, because a shared filesystem hands both replicas the same locked
+ * database rather than giving each its own.
+ *
+ * PER-REPLICA STORAGE IS THE REAL ALTERNATIVE, and it is not modelled here:
+ * it needs the upstream chart's `mode: statefulset` with `volumeClaimTemplates`
+ * so every replica gets its OWN queue directory. This composition renders the
+ * gateway as the chart's default Deployment and mounts one standalone claim, so
+ * the error names that path as future work rather than pretending it exists.
+ *
+ * @param context - Entry point name for the error message
+ * @param resolved - Resolved storage options
+ * @param replicaCount - Collector replica count from the build-time chart
+ *   values, when one was set
+ * @throws Error when a persistent queue is requested with more than one replica
+ */
+export declare function assertQueueReplicaCompatible(context: string, resolved: ResolvedClickStackStorage, replicaCount: unknown): void;
+/**
+ * Render the idempotent retention DDL script.
+ *
+ * IDEMPOTENCE, and why this is a CronJob rather than a one-shot Job: the OTel
+ * tables do not exist until the gateway collector's goose migrations have run,
+ * and TypeKro does not own their DDL — so the script waits for each table to
+ * appear, and re-checks on every run. It only issues `MODIFY TTL` when the
+ * table's current TTL clause is not already the intended one, so a converged
+ * cluster does no metadata churn.
+ *
+ * THE IDEMPOTENCE PROBE COMPARES WHOLE CLAUSES. It extracts the complete TTL
+ * clause out of `system.tables.engine_full` — everything between `TTL ` and
+ * the trailing ` SETTINGS …`, whitespace-collapsed — and tests it for EQUALITY
+ * against {@link ResolvedRetentionEntry.ttlRenderings}. A substring probe was
+ * wrong in both directions (see the doc on `ttlRenderings`), and the actual
+ * clause is echoed on a mismatch so a rendering change is visible in the Job
+ * log instead of showing up as silent per-run churn.
+ *
+ * Notes on the SQL: the extraction deliberately contains no backslash escapes
+ * and no `$` anchors — it strips the `SETTINGS` tail with `replaceRegexpOne`
+ * first and uses the POSIX class `[[:space:]]` — because the expression has to
+ * survive being nested inside a double-quoted shell command substitution.
+ *
+ * @param resolved - Resolved storage options carrying `retentionEntries`
+ * @returns A POSIX shell script for `sh -c`
+ */
+export declare function renderRetentionScript(resolved: ResolvedClickStackStorage): string;
+/**
+ * The persistent queue's contribution to the collector-config overlay.
+ *
+ * ⚠️ A STRUCTURED FRAGMENT, NOT YAML TEXT, and that is the whole point. This
+ * used to return a YAML string that the values mapper CONCATENATED onto the
+ * ingest-pipeline string. Both opened a top-level `service:` key, so the
+ * rendered `custom.config.yaml` declared `service` twice and the OpAMP
+ * supervisor rejected the WHOLE file on every poll:
+ *
+ *   Could not merge local config file: …/custom/custom.config.yaml
+ *   yaml: unmarshal errors: line 18: mapping key "service" already defined at line 1
+ *
+ * The agent then ran with NEITHER the ingest pipelines NOR the queue, while
+ * the Pod still reported Ready off the supervisor's own `health_check` — so
+ * enabling the queue was a silent no-op that also took OTLP ingestion down.
+ * Fragments are merged by `mergeCollectorConfig` (see
+ * `utils/collector-config.ts`) and serialised exactly once, which makes a
+ * duplicate key unrepresentable.
+ *
+ * ⚠️ The YAML lists here REPLACE the supervisor's own lists (the chart's
+ * `customConfig` is a merge, not a deep list append) — see the warning on
+ * {@link ClickStackPersistentQueueOptions}. `service.extensions` is a sequence,
+ * so it UNIONS with any other fragment's contribution before that replacement
+ * happens.
+ *
+ * Every name in `exporterNames` gets its own `sending_queue.storage`. A name
+ * the agent does not define is inert rather than fatal — see
+ * {@link DEFAULT_QUEUE_EXPORTER_NAMES} for why it cannot be checked here.
+ *
+ * ⚠️ THE EXPORTER MAP IS BUILT KEY BY KEY, on a NULL-PROTOTYPE dictionary, and
+ * every name is re-checked. It used to be an `Object.fromEntries` over
+ * `exporterNames`, which is honest enough on its own — `fromEntries` DEFINES an
+ * own property, so it does not pollute — but the overlay merge then copied the
+ * map with `copy[key] = …` onto a plain `{}`, where assigning `__proto__` calls
+ * the inherited SETTER and re-parents the copy instead of adding a key. An
+ * `exporterNames: ['__proto__']` install therefore rendered `exporters: {}`: a
+ * queue that configured nothing, reported no error, and left the real exporter
+ * on its in-memory queue. `resolveClickStackStorage` rejects such a name at the
+ * option, and this function refuses it again so no caller holding a
+ * hand-built `ResolvedClickStackStorage` can route around that.
+ *
+ * @param queue - Resolved persistent-queue configuration
+ * @returns A fragment for `global.otelCollector.customConfig`
+ * @throws Error when a component name is a JavaScript object-model member
+ */
+export declare function persistentQueueConfigFragment(queue: NonNullable<ResolvedClickStackStorage['persistentQueue']>): CollectorConfigFragment;
+/**
+ * Chart values that mount the queue's PersistentVolumeClaim on the collector.
+ *
+ * The claim is a STANDALONE PersistentVolumeClaim owned by the composition
+ * (rendered next to the retention CronJob) and referenced here by
+ * `claimName` — never an `emptyDir` and never a *generic ephemeral volume*.
+ * Kubernetes deletes a generic ephemeral volume's PVC together with the Pod
+ * that owns it, so an ephemeral claim would be destroyed by exactly the
+ * collector restart the queue exists to survive.
+ *
+ * The collector is also PINNED to one replica, unconditionally: the queue is a
+ * bbolt database under an exclusive file lock, so a second replica cannot open
+ * it at all — see {@link assertQueueReplicaCompatible}, which rejects a
+ * build-time `replicaCount` above 1 at construction. The pin makes that
+ * guarantee explicit in the rendered values against later drift.
+ *
+ * ⚠️ `replicaCount: 1` IS NOT ENOUGH ON ITS OWN, which is why
+ * `rollout.strategy: 'Recreate'` travels with it. One replica bounds the
+ * STEADY state, not the state DURING a rollout: the chart leaves the
+ * Deployment on Kubernetes' default `RollingUpdate` (values.yaml `rollout`,
+ * collector chart 0.146.x), whose default `maxSurge: 25%` rounds UP to one
+ * extra Pod. A rollout therefore creates the replacement Pod while the old one
+ * is still running and still holding both the claim and the queue, and that
+ * overlap fails in one of two ways depending on where the replacement lands:
+ *
+ * - **On another node — a stuck rollout.** The ReadWriteOnce claim is still
+ *   attached to the old Pod's node, so the replacement never leaves
+ *   `ContainerCreating` (`Multi-Attach error for volume`). `RollingUpdate`
+ *   will not terminate the old Pod until the new one is Ready, and
+ *   `maxUnavailable: 25%` of one replica rounds DOWN to zero, so nothing gives:
+ *   the rollout DEADLOCKS until `progressDeadlineSeconds` expires.
+ * - **On the same node — a silent two-writer window.** The replacement starts,
+ *   and its `file_storage` extension cannot take bbolt's exclusive lock while
+ *   the old collector holds it. Readiness does not notice: it comes from the
+ *   OpAMP supervisor's own `health_check`, not from the agent's extensions
+ *   (the same reason the missing `custom-config` mount below stayed invisible),
+ *   so the Pod reports Ready and the rollout "succeeds" over a queue the new
+ *   collector could not open. LIVE-OBSERVED on a single-node cluster: under
+ *   `RollingUpdate` the replacement went Ready in under 10s.
+ *
+ * `Recreate` removes the overlap entirely: the old Pod is deleted, its claim
+ * detaches and its lock is released, and only then is the replacement created.
+ *
+ * The cost is a brief gateway outage on every rollout, and the persistent
+ * queue is precisely what makes that cost acceptable: producers upstream of
+ * the gateway retry, and telemetry the gateway already accepted is on the
+ * claim rather than in the departing Pod's memory, so the replacement resumes
+ * draining the same queue instead of starting from an empty one.
+ *
+ * `rollout.rollingUpdate` needs no clearing here. The chart's Deployment
+ * template emits that block only under `if eq .Values.rollout.strategy
+ * "RollingUpdate"`, so `Recreate` drops it — which matters, because a
+ * Deployment carrying `strategy.type: Recreate` alongside a
+ * `strategy.rollingUpdate` block is rejected by the API server.
+ *
+ * ⚠️ THE CHART'S OWN `custom-config` VOLUME IS RE-EMITTED HERE, and must be:
+ * Helm REPLACES a list override instead of appending to it, and these are the
+ * lists through which the chart mounts the ConfigMap it renders from
+ * `global.otelCollector.customConfig` — the overlay that carries the ingest
+ * pipelines AND this queue's own `file_storage` wiring. Dropping it makes the
+ * OpAMP supervisor fail to read `custom.config.yaml` and never start the
+ * agent's receivers, with the Pod still Ready. See
+ * {@link CHART_CUSTOM_CONFIG_VOLUME_NAME} for the live evidence.
+ *
+ * @param queue - Resolved persistent-queue configuration
+ * @param claimName - Name of the PVC the composition creates
+ *   ({@link clickStackQueueClaimName})
+ * @returns Values under the `otel-collector` subchart alias
+ */
+export declare function renderPersistentQueueValues(queue: NonNullable<ResolvedClickStackStorage['persistentQueue']>, claimName: string): Record<string, unknown>;
+/**
+ * Spec of the standalone PersistentVolumeClaim backing the collector queue.
+ *
+ * @param queue - Resolved persistent-queue configuration
+ * @returns A `V1PersistentVolumeClaim.spec` object
+ */
+export declare function renderPersistentQueueClaimSpec(queue: NonNullable<ResolvedClickStackStorage['persistentQueue']>): Record<string, unknown>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/factories/clickstack/utils/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/factories/clickstack/utils/storage.ts"],"names":[],"mappings":"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"}