taurusdb-core 0.1.0

package/dist/diagnostics/metrics-source.d.ts

@@ -0,0 +1,65 @@
+import type { Config } from "../config/index.js";
+import type { SessionContext } from "../context/session-context.js";
+import type { DiagnosisWindow } from "./types.js";
+export type MetricAlias = "cpu_util" | "mem_util" | "connection_count" | "active_connection_count" | "connection_usage" | "qps" | "tps" | "slow_queries" | "storage_used_size" | "storage_write_delay" | "storage_read_delay" | "row_lock_time" | "row_lock_waits" | "long_trx_count" | "write_iops" | "read_iops" | "write_throughput" | "read_throughput" | "temp_tables_per_min";
+export interface MetricPoint {
+    timestamp: number;
+    value: number;
+}
+export interface MetricSummary {
+    alias: MetricAlias;
+    metricName: string;
+    points: MetricPoint[];
+    latest?: number;
+    max?: number;
+    min?: number;
+    avg?: number;
+}
+export interface QueryMetricsInput {
+    aliases: MetricAlias[];
+    timeRange?: DiagnosisWindow;
+}
+export interface MetricsSource {
+    query(input: QueryMetricsInput, ctx: SessionContext): Promise<MetricSummary[]>;
+}
+type CesMetricsSourceOptions = {
+    endpoint: string;
+    projectId: string;
+    instanceId: string;
+    nodeId?: string;
+    authToken?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    securityToken?: string;
+    namespace: string;
+    instanceDimension: string;
+    nodeDimension: string;
+    period: string;
+    filter: "average" | "max" | "min" | "sum" | "variance";
+    requestTimeoutMs: number;
+    defaultLookbackMinutes: number;
+    fetchImpl?: typeof fetch;
+};
+export declare class CesMetricsSource implements MetricsSource {
+    private readonly endpoint;
+    private readonly projectId;
+    private readonly instanceId;
+    private readonly nodeId?;
+    private readonly authToken?;
+    private readonly accessKeyId?;
+    private readonly secretAccessKey?;
+    private readonly securityToken?;
+    private readonly namespace;
+    private readonly instanceDimension;
+    private readonly nodeDimension;
+    private readonly period;
+    private readonly filter;
+    private readonly requestTimeoutMs;
+    private readonly defaultLookbackMinutes;
+    private readonly fetchImpl;
+    constructor(options: CesMetricsSourceOptions);
+    query(input: QueryMetricsInput): Promise<MetricSummary[]>;
+    private postJson;
+}
+export declare function createMetricsSource(config: Config): MetricsSource | undefined;
+export {};

package/dist/diagnostics/metrics-source.js

@@ -0,0 +1,280 @@
+import { fetchHuaweiCloud } from "../cloud/auth.js";
+const TAURUS_CES_METRICS = {
+    cpu_util: "gaussdb_mysql001_cpu_util",
+    mem_util: "gaussdb_mysql002_mem_util",
+    connection_count: "gaussdb_mysql006_conn_count",
+    active_connection_count: "gaussdb_mysql007_conn_active_count",
+    connection_usage: "gaussdb_mysql072_conn_usage",
+    qps: "gaussdb_mysql008_qps",
+    tps: "gaussdb_mysql009_tps",
+    slow_queries: "gaussdb_mysql074_slow_queries",
+    storage_used_size: "gaussdb_mysql048_disk_used_size",
+    storage_write_delay: "gaussdb_mysql104_dfv_write_delay",
+    storage_read_delay: "gaussdb_mysql105_dfv_read_delay",
+    row_lock_time: "gaussdb_mysql121_innodb_row_lock_time",
+    row_lock_waits: "gaussdb_mysql122_innodb_row_lock_waits",
+    long_trx_count: "gaussdb_mysql128_long_trx_count",
+    write_iops: "gaussdb_mysql342_iostat_iops_write",
+    read_iops: "gaussdb_mysql344_iostat_iops_read",
+    write_throughput: "gaussdb_mysql346_iostat_throughput_write",
+    read_throughput: "gaussdb_mysql348_iostat_throughput_read",
+    temp_tables_per_min: "gaussdb_mysql378_create_temp_tbl_per_min",
+};
+function readNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function parseRelativeLookback(value) {
+    if (!value) {
+        return undefined;
+    }
+    const match = value.trim().match(/^(\d+)\s*([mhd])$/i);
+    if (!match) {
+        return undefined;
+    }
+    const amount = Number.parseInt(match[1], 10);
+    switch (match[2].toLowerCase()) {
+        case "m":
+            return amount * 60_000;
+        case "h":
+            return amount * 3_600_000;
+        case "d":
+            return amount * 86_400_000;
+        default:
+            return undefined;
+    }
+}
+function normalizeTimeRange(input, defaultLookbackMinutes) {
+    const now = Date.now();
+    const to = input?.to ? Date.parse(input.to) : now;
+    const safeTo = Number.isFinite(to) ? to : now;
+    const relative = parseRelativeLookback(input?.relative);
+    const from = input?.from
+        ? Date.parse(input.from)
+        : relative
+            ? safeTo - relative
+            : safeTo - defaultLookbackMinutes * 60_000;
+    return {
+        from: Number.isFinite(from)
+            ? from
+            : safeTo - defaultLookbackMinutes * 60_000,
+        to: safeTo,
+    };
+}
+function summarize(alias, metricName, points) {
+    const sorted = [...points].sort((left, right) => left.timestamp - right.timestamp);
+    const values = sorted.map((point) => point.value);
+    return {
+        alias,
+        metricName,
+        points: sorted,
+        latest: values.at(-1),
+        max: values.length > 0 ? Math.max(...values) : undefined,
+        min: values.length > 0 ? Math.min(...values) : undefined,
+        avg: values.length > 0
+            ? values.reduce((sum, value) => sum + value, 0) / values.length
+            : undefined,
+    };
+}
+function parseMetricDataItem(item) {
+    const rawDatapoints = item.datapoints ?? item.data_points ?? item.values;
+    if (!Array.isArray(rawDatapoints)) {
+        return [];
+    }
+    return rawDatapoints
+        .map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return undefined;
+        }
+        const record = entry;
+        const timestamp = readNumber(record.timestamp ?? record.time ?? record.collect_time);
+        const value = readNumber(record.average) ??
+            readNumber(record.max) ??
+            readNumber(record.min) ??
+            readNumber(record.sum) ??
+            readNumber(record.value);
+        if (timestamp === undefined || value === undefined) {
+            return undefined;
+        }
+        return { timestamp, value };
+    })
+        .filter((point) => point !== undefined);
+}
+function pickMetricItems(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return [];
+    }
+    const record = payload;
+    const candidates = record.metrics ?? record.metric_data ?? record.items ?? record.datapoints;
+    if (!Array.isArray(candidates)) {
+        return [];
+    }
+    return candidates.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+}
+async function parseResponse(response) {
+    const payload = (await response.json());
+    return payload && typeof payload === "object" && !Array.isArray(payload)
+        ? payload
+        : {};
+}
+export class CesMetricsSource {
+    endpoint;
+    projectId;
+    instanceId;
+    nodeId;
+    authToken;
+    accessKeyId;
+    secretAccessKey;
+    securityToken;
+    namespace;
+    instanceDimension;
+    nodeDimension;
+    period;
+    filter;
+    requestTimeoutMs;
+    defaultLookbackMinutes;
+    fetchImpl;
+    constructor(options) {
+        this.endpoint = options.endpoint.replace(/\/+$/g, "");
+        this.projectId = options.projectId;
+        this.instanceId = options.instanceId;
+        this.nodeId = options.nodeId;
+        this.authToken = options.authToken;
+        this.accessKeyId = options.accessKeyId;
+        this.secretAccessKey = options.secretAccessKey;
+        this.securityToken = options.securityToken;
+        this.namespace = options.namespace;
+        this.instanceDimension = options.instanceDimension;
+        this.nodeDimension = options.nodeDimension;
+        this.period = options.period;
+        this.filter = options.filter;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+        this.defaultLookbackMinutes = options.defaultLookbackMinutes;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async query(input) {
+        const uniqueAliases = [...new Set(input.aliases)];
+        if (uniqueAliases.length === 0) {
+            return [];
+        }
+        const timeRange = normalizeTimeRange(input.timeRange, this.defaultLookbackMinutes);
+        const path = `/V1.0/${this.projectId}/batch-query-metric-data`;
+        const dimensions = [
+            {
+                name: this.instanceDimension,
+                value: this.instanceId,
+            },
+        ];
+        if (this.nodeId) {
+            dimensions.push({
+                name: this.nodeDimension,
+                value: this.nodeId,
+            });
+        }
+        const metricByName = new Map();
+        for (const alias of uniqueAliases) {
+            metricByName.set(TAURUS_CES_METRICS[alias], alias);
+        }
+        const payload = {
+            metrics: uniqueAliases.map((alias) => ({
+                namespace: this.namespace,
+                metric_name: TAURUS_CES_METRICS[alias],
+                dimensions,
+            })),
+            from: timeRange.from,
+            to: timeRange.to,
+            period: this.period,
+            filter: this.filter,
+        };
+        const body = await this.postJson(path, payload);
+        return pickMetricItems(body)
+            .map((item) => {
+            const metricName = typeof item.metric_name === "string"
+                ? item.metric_name
+                : typeof item.metricName === "string"
+                    ? item.metricName
+                    : undefined;
+            if (!metricName) {
+                return undefined;
+            }
+            const alias = metricByName.get(metricName);
+            if (!alias) {
+                return undefined;
+            }
+            return summarize(alias, metricName, parseMetricDataItem(item));
+        })
+            .filter((item) => item !== undefined);
+    }
+    async postJson(path, payload) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+        try {
+            const body = JSON.stringify(payload);
+            const response = await fetchHuaweiCloud({
+                url: `${this.endpoint}${path}`,
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body,
+                auth: {
+                    authToken: this.authToken,
+                    accessKeyId: this.accessKeyId,
+                    secretAccessKey: this.secretAccessKey,
+                    securityToken: this.securityToken,
+                },
+                fetchImpl: (input, init) => this.fetchImpl(input, {
+                    ...init,
+                    signal: controller.signal,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`CES batch-query-metric-data returned HTTP ${response.status}.`);
+            }
+            return parseResponse(response);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error("CES batch-query-metric-data request failed.");
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+export function createMetricsSource(config) {
+    const ces = config.metricsSource?.ces;
+    if (!ces?.enabled ||
+        !ces.endpoint ||
+        !ces.projectId ||
+        !ces.instanceId ||
+        (!ces.authToken &&
+            !(config.cloud?.accessKeyId && config.cloud?.secretAccessKey))) {
+        return undefined;
+    }
+    return new CesMetricsSource({
+        endpoint: ces.endpoint,
+        projectId: ces.projectId,
+        instanceId: ces.instanceId,
+        nodeId: ces.nodeId,
+        authToken: ces.authToken,
+        accessKeyId: config.cloud?.accessKeyId,
+        secretAccessKey: config.cloud?.secretAccessKey,
+        securityToken: config.cloud?.securityToken,
+        namespace: ces.namespace,
+        instanceDimension: ces.instanceDimension,
+        nodeDimension: ces.nodeDimension,
+        period: ces.period,
+        filter: ces.filter,
+        requestTimeoutMs: ces.requestTimeoutMs,
+        defaultLookbackMinutes: ces.defaultLookbackMinutes,
+    });
+}

package/dist/diagnostics/slow-sql-source/das-source.d.ts

@@ -0,0 +1,43 @@
+import type { SessionContext } from "../../context/session-context.js";
+import type { FindTopSlowSqlInput } from "../types.js";
+import type { ExternalSlowSqlSample, ResolveSlowSqlInput, SlowSqlSource } from "./types.js";
+type DasSlowSqlSourceOptions = {
+    endpoint: string;
+    projectId: string;
+    instanceId: string;
+    authToken?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    securityToken?: string;
+    datastoreType: "MySQL" | "TaurusDB";
+    requestTimeoutMs: number;
+    defaultLookbackMinutes: number;
+    maxRecords: number;
+    maxPages: number;
+    fetchImpl?: typeof fetch;
+};
+export declare class DasSlowSqlSource implements SlowSqlSource {
+    private readonly endpoint;
+    private readonly projectId;
+    private readonly instanceId;
+    private readonly authToken?;
+    private readonly accessKeyId?;
+    private readonly secretAccessKey?;
+    private readonly securityToken?;
+    private readonly datastoreType;
+    private readonly requestTimeoutMs;
+    private readonly defaultLookbackMinutes;
+    private readonly maxRecords;
+    private readonly maxPages;
+    private readonly fetchImpl;
+    constructor(options: DasSlowSqlSourceOptions);
+    resolve(input: ResolveSlowSqlInput, ctx: SessionContext): Promise<ExternalSlowSqlSample | undefined>;
+    findTop(input: FindTopSlowSqlInput, _ctx: SessionContext): Promise<ExternalSlowSqlSample[]>;
+    private fetchSlowQueryLogs;
+    private fetchSqlStatements;
+    private collectPagedCandidates;
+    private pickBestMatch;
+    private toExternalSample;
+    private getJson;
+}
+export {};

package/dist/diagnostics/slow-sql-source/das-source.js

@@ -0,0 +1,170 @@
+import { fetchHuaweiCloud } from "../../cloud/auth.js";
+import { buildQueryString, candidateToExternalSample, formatUnixSeconds, normalizeTimeRange, parseResponse, pickNextMarker, readNumber, readString, scoreCandidate, secondsToMs, sortExternalSamples } from "./utils.js";
+import { parseDasSlowLogCandidate, parseDasSqlStatementCandidate, pickDasTopSlowArrays } from "./parsers.js";
+export class DasSlowSqlSource {
+    endpoint;
+    projectId;
+    instanceId;
+    authToken;
+    accessKeyId;
+    secretAccessKey;
+    securityToken;
+    datastoreType;
+    requestTimeoutMs;
+    defaultLookbackMinutes;
+    maxRecords;
+    maxPages;
+    fetchImpl;
+    constructor(options) {
+        this.endpoint = options.endpoint.replace(/\/+$/g, "");
+        this.projectId = options.projectId;
+        this.instanceId = options.instanceId;
+        this.authToken = options.authToken;
+        this.accessKeyId = options.accessKeyId;
+        this.secretAccessKey = options.secretAccessKey;
+        this.securityToken = options.securityToken;
+        this.datastoreType = options.datastoreType;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+        this.defaultLookbackMinutes = options.defaultLookbackMinutes;
+        this.maxRecords = options.maxRecords;
+        this.maxPages = options.maxPages;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async resolve(input, ctx) {
+        const timeWindow = normalizeTimeRange(input.timeRange, this.defaultLookbackMinutes);
+        const slowLogCandidates = await this.fetchSlowQueryLogs(timeWindow, ctx);
+        const matchedSlowLog = this.pickBestMatch(slowLogCandidates, input);
+        if (matchedSlowLog) {
+            return this.toExternalSample(matchedSlowLog, input, "das_slow_query_logs");
+        }
+        const fullSqlCandidates = await this.fetchSqlStatements(timeWindow, ctx);
+        const matchedFullSql = this.pickBestMatch(fullSqlCandidates, input);
+        if (matchedFullSql) {
+            return this.toExternalSample(matchedFullSql, input, "das_sql_statements");
+        }
+        return undefined;
+    }
+    async findTop(input, _ctx) {
+        const timeWindow = normalizeTimeRange(input.timeRange, this.defaultLookbackMinutes);
+        const payload = await this.getJson(`/v3/${this.projectId}/instances/${this.instanceId}/top-slow-log`, {
+            datastore_type: this.datastoreType,
+            start_at: formatUnixSeconds(new Date(timeWindow.startTime)),
+            end_at: formatUnixSeconds(new Date(timeWindow.endTime)),
+            num: Math.min(input.topN ?? 5, this.maxRecords),
+        });
+        const samples = pickDasTopSlowArrays(payload)
+            .map((item) => candidateToExternalSample({
+            sql: readString(item.template) ??
+                readString(item.sql) ??
+                readString(item.sql_statement),
+            database: readString(item.databases) ?? readString(item.database),
+            user: readString(item.users) ?? readString(item.user),
+            execCount: readNumber(item.times) ?? readNumber(item.count),
+            avgLatencyMs: secondsToMs(item.avg_query_time) ??
+                secondsToMs(item.query_time),
+            avgLockTimeMs: secondsToMs(item.avg_lock_time),
+            avgRowsExamined: readNumber(item.rows_examined),
+            rowsSent: readNumber(item.rows_sent),
+            rawRef: `das:/v3/${this.projectId}/instances/${this.instanceId}/top-slow-log`,
+        }, "das_top_slow_log"))
+            .filter((value) => value !== undefined);
+        return sortExternalSamples(samples, input.sortBy).slice(0, Math.min(input.topN ?? 5, this.maxRecords));
+    }
+    async fetchSlowQueryLogs(timeWindow, ctx) {
+        return this.collectPagedCandidates("/slow-query-logs", timeWindow, ctx, "slow_logs", parseDasSlowLogCandidate);
+    }
+    async fetchSqlStatements(timeWindow, ctx) {
+        return this.collectPagedCandidates("/sql-statements", timeWindow, ctx, "sql_statements", parseDasSqlStatementCandidate);
+    }
+    async collectPagedCandidates(suffix, timeWindow, ctx, arrayKey, parser) {
+        const output = [];
+        let marker;
+        for (let page = 0; page < this.maxPages; page += 1) {
+            const path = `/v3/${this.projectId}/instances/${this.instanceId}${suffix}`;
+            const payload = await this.getJson(path, {
+                datastore_type: this.datastoreType,
+                start_at: formatUnixSeconds(new Date(timeWindow.startTime)),
+                end_at: formatUnixSeconds(new Date(timeWindow.endTime)),
+                limit: this.maxRecords,
+                marker,
+            });
+            const items = Array.isArray(payload[arrayKey])
+                ? payload[arrayKey].filter((item) => item !== null && typeof item === "object" && !Array.isArray(item))
+                : [];
+            for (const item of items) {
+                const candidate = parser(item, `das:${path}`);
+                if (!candidate) {
+                    continue;
+                }
+                if (ctx.database &&
+                    candidate.database &&
+                    candidate.database !== ctx.database) {
+                    continue;
+                }
+                output.push(candidate);
+            }
+            marker = pickNextMarker(payload);
+            if (!marker || items.length === 0 || output.length >= this.maxRecords) {
+                break;
+            }
+        }
+        return output.slice(0, this.maxRecords);
+    }
+    pickBestMatch(candidates, input) {
+        const scored = candidates
+            .map((candidate) => ({ candidate, score: scoreCandidate(candidate, input) }))
+            .sort((left, right) => right.score - left.score);
+        if (scored.length === 0) {
+            return undefined;
+        }
+        if (input.sqlHash || input.digestText) {
+            return scored[0].score > 0 ? scored[0].candidate : undefined;
+        }
+        return scored[0].candidate;
+    }
+    toExternalSample(candidate, input, source) {
+        const sample = candidateToExternalSample(candidate, source);
+        if (!sample) {
+            return undefined;
+        }
+        return {
+            ...sample,
+            sqlHash: input.sqlHash ?? sample.sqlHash,
+            digestText: input.digestText ?? sample.digestText,
+        };
+    }
+    async getJson(path, params) {
+        const queryString = buildQueryString(params);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+        try {
+            const response = await fetchHuaweiCloud({
+                url: `${this.endpoint}${path}${queryString ? `?${queryString}` : ""}`,
+                method: "GET",
+                headers: {
+                    "content-type": "application/json",
+                },
+                auth: {
+                    authToken: this.authToken,
+                    accessKeyId: this.accessKeyId,
+                    secretAccessKey: this.secretAccessKey,
+                    securityToken: this.securityToken,
+                },
+                fetchImpl: (input, init) => this.fetchImpl(input, {
+                    ...init,
+                    signal: controller.signal,
+                }),
+            });
+            if (!response.ok) {
+                return {};
+            }
+            return parseResponse(response);
+        }
+        catch {
+            return {};
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/diagnostics/slow-sql-source/factory.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from "../../config/index.js";
+import type { DiagnoseSlowQueryInput } from "../types.js";
+import type { ResolveSlowSqlInput, SlowSqlSource } from "./types.js";
+export declare function createSlowSqlSource(config: Config): SlowSqlSource | undefined;
+export declare function buildResolveSlowSqlInput(input: DiagnoseSlowQueryInput): ResolveSlowSqlInput;

package/dist/diagnostics/slow-sql-source/factory.js

@@ -0,0 +1,87 @@
+import { DasSlowSqlSource } from "./das-source.js";
+import { TaurusApiSlowSqlSource } from "./taurus-api-source.js";
+import { sortExternalSamples } from "./utils.js";
+class CompositeSlowSqlSource {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async resolve(input, ctx) {
+        for (const source of this.sources) {
+            const resolved = await source.resolve(input, ctx);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        return undefined;
+    }
+    async findTop(input, ctx) {
+        const allSamples = (await Promise.all(this.sources.map((source) => source.findTop ? source.findTop(input, ctx) : []))).flat();
+        const deduped = allSamples.filter((sample, index, allItems) => {
+            const key = `${sample.source}:${sample.sqlHash}:${sample.digestText ?? ""}:${sample.sql}`;
+            return (allItems.findIndex((candidate) => {
+                const candidateKey = `${candidate.source}:${candidate.sqlHash}:${candidate.digestText ?? ""}:${candidate.sql}`;
+                return candidateKey === key;
+            }) === index);
+        });
+        return sortExternalSamples(deduped, input.sortBy).slice(0, Math.min(input.topN ?? 5, deduped.length));
+    }
+}
+export function createSlowSqlSource(config) {
+    const sources = [];
+    const taurusApi = config.slowSqlSource?.taurusApi;
+    if (taurusApi?.enabled &&
+        taurusApi.endpoint &&
+        taurusApi.projectId &&
+        taurusApi.instanceId &&
+        taurusApi.nodeId &&
+        (taurusApi.authToken ||
+            (config.cloud?.accessKeyId && config.cloud?.secretAccessKey))) {
+        sources.push(new TaurusApiSlowSqlSource({
+            endpoint: taurusApi.endpoint,
+            projectId: taurusApi.projectId,
+            instanceId: taurusApi.instanceId,
+            nodeId: taurusApi.nodeId,
+            authToken: taurusApi.authToken,
+            accessKeyId: config.cloud?.accessKeyId,
+            secretAccessKey: config.cloud?.secretAccessKey,
+            securityToken: config.cloud?.securityToken,
+            language: taurusApi.language,
+            requestTimeoutMs: taurusApi.requestTimeoutMs,
+            defaultLookbackMinutes: taurusApi.defaultLookbackMinutes,
+            maxRecords: taurusApi.maxRecords,
+        }));
+    }
+    const das = config.slowSqlSource?.das;
+    if (das?.enabled &&
+        das.endpoint &&
+        das.projectId &&
+        das.instanceId &&
+        (das.authToken || (config.cloud?.accessKeyId && config.cloud?.secretAccessKey))) {
+        sources.push(new DasSlowSqlSource({
+            endpoint: das.endpoint,
+            projectId: das.projectId,
+            instanceId: das.instanceId,
+            authToken: das.authToken,
+            accessKeyId: config.cloud?.accessKeyId,
+            secretAccessKey: config.cloud?.secretAccessKey,
+            securityToken: config.cloud?.securityToken,
+            datastoreType: das.datastoreType,
+            requestTimeoutMs: das.requestTimeoutMs,
+            defaultLookbackMinutes: das.defaultLookbackMinutes,
+            maxRecords: das.maxRecords,
+            maxPages: das.maxPages,
+        }));
+    }
+    if (sources.length === 0) {
+        return undefined;
+    }
+    return sources.length === 1 ? sources[0] : new CompositeSlowSqlSource(sources);
+}
+export function buildResolveSlowSqlInput(input) {
+    return {
+        sqlHash: input.sqlHash,
+        digestText: input.digestText,
+        timeRange: input.timeRange,
+    };
+}

package/dist/diagnostics/slow-sql-source/parsers.d.ts

@@ -0,0 +1,7 @@
+import type { TaurusApiCandidate } from "./types.js";
+export declare function pickArrayCandidate(payload: unknown): Record<string, unknown>[];
+export declare function parseStatisticsCandidate(item: Record<string, unknown>, rawRef: string): TaurusApiCandidate | undefined;
+export declare function parseDetailCandidate(item: Record<string, unknown>, rawRef: string): TaurusApiCandidate | undefined;
+export declare function parseDasSlowLogCandidate(item: Record<string, unknown>, rawRef: string): TaurusApiCandidate | undefined;
+export declare function parseDasSqlStatementCandidate(item: Record<string, unknown>, rawRef: string): TaurusApiCandidate | undefined;
+export declare function pickDasTopSlowArrays(payload: Record<string, unknown>): Record<string, unknown>[];