@perses-dev/greptimedb-plugin 0.1.0-beta.0

package/lib/cjs/queries/greptimedb-time-series-query/get-greptimedb-data.js

@@ -0,0 +1,184 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTimeSeriesData", {
+    enumerable: true,
+    get: function() {
+        return getTimeSeriesData;
+    }
+});
+const _constants = require("../constants");
+const _greptimedbquerydatamodel = require("../greptimedb-query-data-model");
+function isLikelyNumericType(dataType) {
+    if (!dataType) return false;
+    const t = dataType.toLowerCase();
+    return t.includes('int') || t.includes('float') || t.includes('double') || t.includes('decimal') || t.includes('number');
+}
+function buildSeriesName(valueColumnName, labels) {
+    const entries = Object.entries(labels);
+    if (entries.length === 0) {
+        return valueColumnName;
+    }
+    return entries.map(([k, v])=>`${k}=${v}`).join(',');
+}
+function buildTimeSeries(records, fallbackTimestampMs) {
+    const columnSchemas = records?.schema?.column_schemas ?? [];
+    const rows = records?.rows ?? [];
+    if (!columnSchemas.length || !rows.length) {
+        return [];
+    }
+    const timeIndex = (0, _greptimedbquerydatamodel.findTimeColumnIndex)(columnSchemas);
+    if (timeIndex === -1) {
+        // Stat-style queries (e.g. `select count(*)`) may return a single numeric column with no timestamp.
+        // In this case, emit a synthetic single-point series to keep numeric panels working.
+        const scalarValueIndex = columnSchemas.findIndex((c)=>isLikelyNumericType(c.data_type));
+        if (scalarValueIndex === -1) {
+            return [];
+        }
+        const scalarColumnName = columnSchemas[scalarValueIndex]?.name ?? 'value';
+        const scalarValues = [];
+        rows.forEach((row, rowIndex)=>{
+            const raw = row?.[scalarValueIndex];
+            const value = typeof raw === 'number' ? raw : Number(raw);
+            if (!Number.isFinite(value)) {
+                return;
+            }
+            // Spread multiple rows by 1ms so ordering is stable.
+            scalarValues.push([
+                fallbackTimestampMs + rowIndex,
+                value
+            ]);
+        });
+        if (scalarValues.length === 0) {
+            return [];
+        }
+        return [
+            {
+                name: scalarColumnName,
+                labels: {},
+                values: scalarValues
+            }
+        ];
+    }
+    // Choose a "value" column. Prefer greptime conventions, then fall back to the first numeric column.
+    let valueIndex = columnSchemas.findIndex((c, idx)=>idx !== timeIndex && c.name.toLowerCase() === 'greptime_value');
+    if (valueIndex === -1) {
+        valueIndex = columnSchemas.findIndex((c, idx)=>idx !== timeIndex && c.name.toLowerCase() === 'value');
+    }
+    if (valueIndex === -1) {
+        valueIndex = columnSchemas.findIndex((c, idx)=>idx !== timeIndex && isLikelyNumericType(c.data_type));
+    }
+    if (valueIndex === -1) {
+        // Last resort: treat the first non-time column as value.
+        valueIndex = columnSchemas.findIndex((_, idx)=>idx !== timeIndex);
+    }
+    const valueColumnName = columnSchemas[valueIndex]?.name ?? 'value';
+    // Chart-safe default: group rows into standard timeseries (multiple points per series).
+    const seriesMap = new Map();
+    for (const row of rows){
+        const tsMs = (0, _greptimedbquerydatamodel.toTimestampMs)(row?.[timeIndex], columnSchemas[timeIndex]?.data_type);
+        if (tsMs === null) {
+            continue;
+        }
+        const raw = row?.[valueIndex];
+        const value = typeof raw === 'number' ? raw : Number(raw);
+        if (!Number.isFinite(value)) {
+            continue;
+        }
+        const labels = {};
+        columnSchemas.forEach((col, idx)=>{
+            if (idx === timeIndex || idx === valueIndex) return;
+            const v = row?.[idx];
+            labels[col.name] = v === null || v === undefined ? '' : String(v);
+        });
+        // Stable series key by label set.
+        const labelsKey = columnSchemas.filter((_, idx)=>idx !== timeIndex && idx !== valueIndex).map((c)=>`${c.name}=${labels[c.name] ?? ''}`).join('|');
+        const key = `${valueColumnName}|${labelsKey}`;
+        const existing = seriesMap.get(key);
+        if (existing) {
+            existing.values.push([
+                tsMs,
+                value
+            ]);
+        } else {
+            seriesMap.set(key, {
+                name: buildSeriesName(valueColumnName, labels),
+                labels,
+                values: [
+                    [
+                        tsMs,
+                        value
+                    ]
+                ]
+            });
+        }
+    }
+    return Array.from(seriesMap.values()).filter((s)=>s.values.length > 0);
+}
+function inferStepMsFromSeries(series, fallbackStepMs) {
+    let minDeltaMs = Number.POSITIVE_INFINITY;
+    for (const s of series){
+        const sortedTimestamps = [
+            ...s.values.map(([ts])=>ts)
+        ].sort((a, b)=>a - b);
+        for(let i = 1; i < sortedTimestamps.length; i++){
+            const delta = sortedTimestamps[i] - sortedTimestamps[i - 1];
+            if (delta > 0 && delta < minDeltaMs) {
+                minDeltaMs = delta;
+            }
+        }
+    }
+    return Number.isFinite(minDeltaMs) ? minDeltaMs : fallbackStepMs;
+}
+const getTimeSeriesData = async (spec, context)=>{
+    if (!spec.query) {
+        return {
+            series: []
+        };
+    }
+    const { start, end } = context.timeRange;
+    const query = (0, _greptimedbquerydatamodel.replaceQueryVariables)(spec.query, context.variableState, context.timeRange);
+    const client = await context.datasourceStore.getDatasourceClient(spec.datasource ?? _constants.DEFAULT_DATASOURCE);
+    const response = await client.query({
+        start: start.getTime().toString(),
+        end: end.getTime().toString(),
+        query
+    });
+    if (response.status === 'error') {
+        throw new Error(response.error ?? 'GreptimeDB query failed');
+    }
+    const records = (0, _greptimedbquerydatamodel.normalizeRecords)(response.data);
+    const tableColumns = records?.schema?.column_schemas ?? [];
+    const tableRows = records?.rows ?? [];
+    const series = buildTimeSeries(records, end.getTime());
+    const stepMs = inferStepMsFromSeries(series, context.suggestedStepMs || 30 * 1000);
+    return {
+        series,
+        timeRange: {
+            start,
+            end
+        },
+        stepMs,
+        metadata: {
+            executedQueryString: query,
+            records,
+            table: {
+                columns: tableColumns,
+                rows: tableRows
+            }
+        }
+    };
+};

package/lib/cjs/queries/greptimedb-time-series-query/greptimedb-query-types.js

@@ -0,0 +1,16 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/lib/cjs/queries/greptimedb-time-series-query/index.js

@@ -0,0 +1,33 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./get-greptimedb-data"), exports);
+_export_star(require("./GreptimeDBQuery"), exports);
+_export_star(require("./GreptimeDBQueryEditor"), exports);
+_export_star(require("./greptimedb-query-types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/lib/cjs/queries/greptimedb-trace-query/GreptimeDBTraceQuery.js

@@ -0,0 +1,40 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GreptimeDBTraceQuery", {
+    enumerable: true,
+    get: function() {
+        return GreptimeDBTraceQuery;
+    }
+});
+const _pluginsystem = require("@perses-dev/plugin-system");
+const _getgreptimedbtracedata = require("./get-greptimedb-trace-data");
+const _GreptimeDBTraceQueryEditor = require("./GreptimeDBTraceQueryEditor");
+const GreptimeDBTraceQuery = {
+    getTraceData: _getgreptimedbtracedata.getGreptimeDBTraceData,
+    OptionsEditorComponent: _GreptimeDBTraceQueryEditor.GreptimeDBTraceQueryEditor,
+    createInitialOptions: ()=>({
+            query: ''
+        }),
+    dependsOn: (spec)=>{
+        const queryVariables = (0, _pluginsystem.parseVariables)(spec.query);
+        return {
+            variables: [
+                ...new Set(queryVariables)
+            ]
+        };
+    }
+};

package/lib/cjs/queries/greptimedb-trace-query/GreptimeDBTraceQueryEditor.js

@@ -0,0 +1,79 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GreptimeDBTraceQueryEditor", {
+    enumerable: true,
+    get: function() {
+        return GreptimeDBTraceQueryEditor;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _material = require("@mui/material");
+const _immer = require("immer");
+const _pluginsystem = require("@perses-dev/plugin-system");
+const _react = require("react");
+const _components = require("../../components");
+const _constants = require("../constants");
+const _queryeditormodel = require("../query-editor-model");
+function GreptimeDBTraceQueryEditor(props) {
+    const { onChange, value } = props;
+    const { datasource } = value;
+    const selectedDatasource = datasource ?? _constants.DEFAULT_DATASOURCE;
+    const { query, handleQueryChange, handleQueryBlur } = (0, _queryeditormodel.useQueryState)(props);
+    const handleDatasourceChange = (newDatasourceSelection)=>{
+        if (!(0, _pluginsystem.isVariableDatasource)(newDatasourceSelection) && newDatasourceSelection.kind === _constants.DATASOURCE_KIND) {
+            onChange((0, _immer.produce)(value, (draft)=>{
+                draft.datasource = newDatasourceSelection;
+            }));
+            return;
+        }
+        throw new Error('Got unexpected non GreptimeDB datasource selection');
+    };
+    const handleQueryExecute = (queryValue)=>{
+        onChange((0, _immer.produce)(value, (draft)=>{
+            draft.query = queryValue;
+        }));
+    };
+    const handleGreptimeDBQueryChange = (0, _react.useCallback)((next)=>{
+        handleQueryChange(next);
+    }, [
+        handleQueryChange
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_material.Stack, {
+        spacing: 1.5,
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_pluginsystem.DatasourceSelect, {
+                datasourcePluginKind: _constants.DATASOURCE_KIND,
+                value: selectedDatasource,
+                onChange: handleDatasourceChange,
+                label: "GreptimeDB Datasource",
+                notched: true
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_components.GreptimeDBQLEditor, {
+                value: query,
+                onChange: handleGreptimeDBQueryChange,
+                onBlur: handleQueryBlur,
+                onKeyDown: (event)=>{
+                    if (event.key === 'Enter' && (event.ctrlKey || event.metaKey)) {
+                        event.preventDefault();
+                        handleQueryExecute(query);
+                    }
+                },
+                placeholder: "Enter SQL for trace search or trace details"
+            })
+        ]
+    });
+}