@perses-dev/plugin-system 0.54.0-beta.0 → 0.54.0-beta.2

package/dist/cjs/model/calculations.js

@@ -0,0 +1,178 @@
+// 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
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CALCULATIONS_CONFIG () {
+        return CALCULATIONS_CONFIG;
+    },
+    get CalculationsMap () {
+        return CalculationsMap;
+    },
+    get DEFAULT_CALCULATION () {
+        return DEFAULT_CALCULATION;
+    },
+    get getCalculation () {
+        return getCalculation;
+    },
+    get getCalculations () {
+        return getCalculations;
+    }
+});
+const DEFAULT_CALCULATION = 'last'; // aligned with cue
+const CalculationsMap = {
+    first: first,
+    last: last,
+    'first-number': firstNumber,
+    'last-number': lastNumber,
+    mean: mean,
+    sum: sum,
+    min: min,
+    max: max
+};
+const CALCULATIONS_CONFIG = {
+    first: {
+        label: 'First',
+        description: 'First value'
+    },
+    last: {
+        label: 'Last',
+        description: 'Last value'
+    },
+    'first-number': {
+        label: 'First *',
+        description: 'First numeric value'
+    },
+    'last-number': {
+        label: 'Last *',
+        description: 'Last numeric value'
+    },
+    mean: {
+        label: 'Avg',
+        description: 'Average value excluding nulls'
+    },
+    sum: {
+        label: 'Sum',
+        description: 'The sum of all values'
+    },
+    min: {
+        label: 'Min',
+        description: 'Minimum value'
+    },
+    max: {
+        label: 'Max',
+        description: 'Maximum value'
+    }
+};
+function getCalculations(values, includeCalculations) {
+    const calculations = includeCalculations.reduce((initResult, calculation)=>{
+        initResult[calculation] = undefined;
+        return initResult;
+    }, {});
+    // We save these values as separate values instead of directly setting them
+    // in the calculations because they are needed by multiple calculations.
+    let nonNullCount = 0;
+    let sum = 0;
+    // We use this large function capable of performing one or more calculations
+    // in a single iteration of the data to minimize the performance impact of
+    // generating multiple calculations for large timeseries values. This is
+    // less optimized for certain single calculations when done in isolation (e.g.
+    // `last`), but will be more performant in the more expensive cases where
+    // multiple values are being used (e.g. table legend).
+    values.forEach((tuple, i)=>{
+        const value = tuple[1];
+        if (i === 0 && 'first' in calculations) {
+            calculations.first = value;
+        }
+        if (i === values.length - 1 && 'last' in calculations) {
+            calculations.last = value;
+        }
+        // Handling specific to non-null values.
+        if (typeof value === 'number') {
+            nonNullCount += 1;
+            sum += value;
+            if ('first-number' in calculations && calculations['first-number'] === undefined) {
+                // Save the first number we see.
+                calculations['first-number'] = value;
+            }
+            if ('last-number' in calculations) {
+                // Keep setting the numbers we see, which will eventually be set to the
+                // last number when finished iterating.
+                calculations['last-number'] = value;
+            }
+            if ('min' in calculations) {
+                if (typeof calculations.min !== 'number') {
+                    // Init the first time we see a number
+                    calculations.min = value;
+                } else {
+                    // Use lowest value once initialized
+                    calculations.min = Math.min(calculations.min, value);
+                }
+            }
+            if ('max' in calculations) {
+                if (typeof calculations.max !== 'number') {
+                    // Init the first time we see a number
+                    calculations.max = value;
+                } else {
+                    // Use highest value once initialized
+                    calculations.max = Math.max(calculations.max, value);
+                }
+            }
+        }
+    });
+    // Set calculations that require iterating over all values.
+    if (nonNullCount > 0 && 'sum' in calculations) {
+        calculations.sum = sum;
+    }
+    if (nonNullCount > 0 && 'mean' in calculations) {
+        calculations.mean = sum / nonNullCount;
+    }
+    return calculations;
+}
+function getCalculation(values, calculation) {
+    return getCalculations(values, [
+        calculation
+    ])[calculation];
+}
+function first(values) {
+    return getCalculation(values, 'first');
+}
+function last(values) {
+    return getCalculation(values, 'last');
+}
+function firstNumber(values) {
+    return getCalculation(values, 'first-number');
+}
+function lastNumber(values) {
+    return getCalculation(values, 'last-number');
+}
+function mean(values) {
+    return getCalculation(values, 'mean');
+}
+function sum(values) {
+    return getCalculation(values, 'sum');
+}
+function min(values) {
+    return getCalculation(values, 'min');
+}
+function max(values) {
+    return getCalculation(values, 'max');
+}

package/dist/cjs/model/index.js

@@ -26,6 +26,9 @@ _export_star(require("./time-series-queries"), exports);
 _export_star(require("./trace-queries"), exports);
 _export_star(require("./profile-queries"), exports);
 _export_star(require("./variables"), exports);
+_export_star(require("./calculations"), exports);
+_export_star(require("./alerts-queries"), exports);
+_export_star(require("./silences-queries"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/model/legend.js

@@ -43,7 +43,8 @@ _export(exports, {
         return validateLegendSpec;
     }
 });
-const _core = require("@perses-dev/core");
+const _components = require("@perses-dev/components");
+const _calculations = require("./calculations");
 const legendValues = [
     'mean',
     'first',
@@ -89,7 +90,7 @@ const LEGEND_SIZE_CONFIG = {
     }
 };
 const LEGEND_VALUE_CONFIG = legendValues.reduce((config, value)=>{
-    config[value] = _core.CALCULATIONS_CONFIG[value];
+    config[value] = _calculations.CALCULATIONS_CONFIG[value];
     return config;
 }, {});
 function validateLegendSpec(legend) {
@@ -97,13 +98,13 @@ function validateLegendSpec(legend) {
         // undefined is valid since this is how legend is hidden by default
         return true;
     }
-    if (!(0, _core.isValidLegendPosition)(legend.position)) {
+    if (!(0, _components.isValidLegendPosition)(legend.position)) {
         return false;
     }
-    if (legend.mode && !(0, _core.isValidLegendMode)(legend.mode)) {
+    if (legend.mode && !(0, _components.isValidLegendMode)(legend.mode)) {
         return false;
     }
-    if (legend.size && !(0, _core.isValidLegendSize)(legend.size)) {
+    if (legend.size && !(0, _components.isValidLegendSize)(legend.size)) {
         return false;
     }
     return true;

package/dist/cjs/model/log-volume-utils.js

@@ -1,3 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateVolumeInterval", {
+    enumerable: true,
+    get: function() {
+        return calculateVolumeInterval;
+    }
+});
 // 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.
@@ -11,16 +21,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // Target number of bars for log volume histogram
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "calculateVolumeInterval", {
-    enumerable: true,
-    get: function() {
-        return calculateVolumeInterval;
-    }
-});
 const TARGET_HISTOGRAM_BARS = 40;
 // Standard intervals for histogram calculations (in milliseconds)
 const STANDARD_INTERVALS = [

package/dist/cjs/model/plugin-loading.js

@@ -20,21 +20,37 @@ Object.defineProperty(exports, "dynamicImportPluginLoader", {
         return dynamicImportPluginLoader;
     }
 });
+const _plugins = require("./plugins");
 function dynamicImportPluginLoader(plugins) {
-    const importMap = new Map(plugins.map((plugin)=>[
-            plugin.resource,
-            plugin.importPlugin
-        ]));
+    const importMap = new Map();
+    for (const p of plugins){
+        const { resource, resource: { kind, metadata: { name, registry, version } }, importPlugin } = p;
+        importMap.set((0, _plugins.getPluginModuleCompoundKey)({
+            kind,
+            name,
+            registry,
+            version
+        }), {
+            resource,
+            importPlugin
+        });
+    }
     return {
         async getInstalledPlugins () {
-            return Promise.resolve(Array.from(importMap.keys()));
+            return Promise.resolve(Array.from(importMap.values()).map((v)=>v.resource));
         },
         importPluginModule (resource) {
-            const importFn = importMap.get(resource);
-            if (importFn === undefined) {
+            const { kind, metadata: { name, version, registry } } = resource;
+            const { importPlugin } = importMap.get((0, _plugins.getPluginModuleCompoundKey)({
+                kind,
+                name,
+                registry,
+                version
+            })) || {};
+            if (importPlugin === undefined) {
                 throw new Error('Plugin not found');
             }
-            return importFn();
+            return importPlugin();
         }
     };
 }

package/dist/cjs/model/plugins.js

@@ -14,3 +14,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "getPluginModuleCompoundKey", {
+    enumerable: true,
+    get: function() {
+        return getPluginModuleCompoundKey;
+    }
+});
+function getPluginModuleCompoundKey(compoundKey) {
+    const { kind, name, registry, version } = compoundKey;
+    return `${kind}:${name}:${registry ?? ''}:${version ?? ''}`;
+}

package/dist/cjs/model/silences-queries.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/dist/cjs/model/time-series-queries.js

@@ -14,3 +14,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "isTimeSeriesValueTuple", {
+    enumerable: true,
+    get: function() {
+        return isTimeSeriesValueTuple;
+    }
+});
+function isTimeSeriesValueTuple(data) {
+    if (data.length !== 2) return false;
+    return true;
+}

package/dist/cjs/remote/PluginRuntime.js

@@ -156,6 +156,14 @@ const getPluginRuntime = ()=>{
                         requiredVersion: '^0.53.1'
                     }
                 },
+                '@perses-dev/client': {
+                    version: '0.54.0-beta.1',
+                    lib: ()=>require('@perses-dev/client'),
+                    shareConfig: {
+                        singleton: true,
+                        requiredVersion: '^0.54.0-beta.1'
+                    }
+                },
                 '@perses-dev/components': {
                     version: '0.53.1',
                     lib: ()=>require('@perses-dev/components'),
@@ -268,28 +276,49 @@ const getPluginRuntime = ()=>{
     }
     return instance;
 };
-const registerRemote = (name, baseURL)=>{
+function getModuleFederationRemoteName(name, registry, version) {
+    return `${name}:${registry ?? ''}:${version ?? ''}`;
+}
+const registerRemote = (name, registry, version, baseURL)=>{
     const pluginRuntime = getPluginRuntime();
-    const existingRemote = pluginRuntime.options.remotes.find((remote)=>remote.name === name);
+    const registryName = getModuleFederationRemoteName(name, registry, version);
+    const existingRemote = pluginRuntime.options.remotes.find((remote)=>remote.name === registryName);
     if (!existingRemote) {
-        const remoteEntryURL = baseURL ? `${baseURL}/${name}/mf-manifest.json` : `/plugins/${name}/mf-manifest.json`;
+        const nameVersionRegistry = [
+            name,
+            version,
+            registry
+        ].filter(Boolean).join('~');
+        const prefix = baseURL || '/plugins';
+        const remoteEntryURL = `${prefix}/${nameVersionRegistry}/mf-manifest.json`;
         pluginRuntime.registerRemotes([
             {
-                name,
+                name: registryName,
                 entry: remoteEntryURL,
-                alias: name
+                alias: registryName
             }
         ]);
     }
 };
-const loadPlugin = async (moduleName, pluginName, baseURL)=>{
-    registerRemote(moduleName, baseURL);
+const loadPlugin = async (target)=>{
+    const { moduleName, pluginName, registry, version, baseURL } = target;
+    registerRemote(moduleName, registry, version, baseURL);
     const pluginRuntime = getPluginRuntime();
-    return pluginRuntime.loadRemote(`${moduleName}/${pluginName}`);
+    const registryName = getModuleFederationRemoteName(moduleName, registry, version);
+    return pluginRuntime.loadRemote(`${registryName}/${pluginName}`);
 };
 function usePluginRuntime({ plugin }) {
     return {
         pluginRuntime: getPluginRuntime(),
-        loadPlugin: ()=>loadPlugin(plugin.moduleName, plugin.name, plugin.baseURL)
+        loadPlugin: ()=>{
+            const { moduleName, name: pluginName, registry, version, baseURL } = plugin;
+            return loadPlugin({
+                moduleName,
+                pluginName,
+                registry,
+                version,
+                baseURL
+            });
+        }
     };
 }

package/dist/cjs/remote/remotePluginLoader.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "remotePluginLoader", {
         return remotePluginLoader;
     }
 });
+const _pluginsystem = require("@perses-dev/plugin-system");
 const _PluginRuntime = require("./PluginRuntime");
 const isPluginMetadata = (plugin)=>{
     return typeof plugin === 'object' && plugin !== null && 'kind' in plugin && 'spec' in plugin && typeof plugin.spec === 'object' && plugin.spec !== null && 'name' in plugin.spec;
@@ -59,17 +60,39 @@ function remotePluginLoader(options) {
             return pluginModules;
         },
         importPluginModule: async (resource)=>{
-            const pluginModuleName = resource.metadata.name;
+            const { name: pluginModuleName, version, registry } = resource.metadata;
             const pluginModule = {};
-            for (const plugin of resource.spec.plugins){
-                const remotePluginModule = await (0, _PluginRuntime.loadPlugin)(pluginModuleName, plugin.spec.name, pluginsAssetsPath);
+            const loadPromises = resource.spec.plugins.map(async (plugin)=>{
+                const remotePluginModule = await (0, _PluginRuntime.loadPlugin)({
+                    moduleName: pluginModuleName,
+                    pluginName: plugin.spec.name,
+                    registry,
+                    version,
+                    baseURL: pluginsAssetsPath
+                });
                 const remotePlugin = remotePluginModule?.[plugin.spec.name];
                 if (remotePlugin) {
-                    pluginModule[plugin.spec.name] = remotePlugin;
+                    return {
+                        kind: plugin.kind,
+                        name: plugin.spec.name,
+                        remotePlugin
+                    };
                 } else {
                     console.error(`RemotePluginLoader: Error loading plugin ${plugin.spec.name}`);
+                    return null;
                 }
-            }
+            });
+            const loadedPlugins = await Promise.all(loadPromises);
+            loadedPlugins.forEach((item)=>{
+                if (item?.remotePlugin) {
+                    pluginModule[(0, _pluginsystem.getPluginModuleCompoundKey)({
+                        kind: item.kind,
+                        name: item.name,
+                        registry,
+                        version
+                    })] = item.remotePlugin;
+                }
+            });
             return pluginModule;
         }
     };

package/dist/cjs/runtime/DataQueriesProvider/DataQueriesProvider.js

@@ -39,6 +39,8 @@ const _react = require("react");
 const _timeseriesqueries = require("../time-series-queries");
 const _tracequeries = require("../trace-queries");
 const _profilequeries = require("../profile-queries");
+const _alertsqueries = require("../alerts-queries");
+const _silencesqueries = require("../silences-queries");
 const _UsageMetricsProvider = require("../UsageMetricsProvider");
 const _logqueries = require("../log-queries");
 const _model = require("./model");
@@ -89,23 +91,33 @@ function DataQueriesProvider(props) {
     const profileResults = (0, _profilequeries.useProfileQueries)(profileQueries);
     const logQueries = queryDefinitions.filter((definition)=>definition.kind === 'LogQuery');
     const logResults = (0, _logqueries.useLogQueries)(logQueries);
+    const alertsQueries = queryDefinitions.filter((definition)=>definition.kind === 'AlertsQuery');
+    const alertsResults = (0, _alertsqueries.useAlertsQueries)(alertsQueries);
+    const silencesQueries = queryDefinitions.filter((definition)=>definition.kind === 'SilencesQuery');
+    const silencesResults = (0, _silencesqueries.useSilencesQueries)(silencesQueries);
     const refetchAll = (0, _react.useCallback)(()=>{
         timeSeriesResults.forEach((result)=>result.refetch());
         traceResults.forEach((result)=>result.refetch());
         profileResults.forEach((result)=>result.refetch());
         logResults.forEach((result)=>result.refetch());
+        alertsResults.forEach((result)=>result.refetch());
+        silencesResults.forEach((result)=>result.refetch());
     }, [
         timeSeriesResults,
         traceResults,
         profileResults,
-        logResults
+        logResults,
+        alertsResults,
+        silencesResults
     ]);
     const ctx = (0, _react.useMemo)(()=>{
         const mergedQueryResults = [
             ...(0, _model.transformQueryResults)(timeSeriesResults, timeSeriesQueries),
             ...(0, _model.transformQueryResults)(traceResults, traceQueries),
             ...(0, _model.transformQueryResults)(profileResults, profileQueries),
-            ...(0, _model.transformQueryResults)(logResults, logQueries)
+            ...(0, _model.transformQueryResults)(logResults, logQueries),
+            ...(0, _model.transformQueryResults)(alertsResults, alertsQueries),
+            ...(0, _model.transformQueryResults)(silencesResults, silencesQueries)
         ];
         if (queryOptions?.enabled) {
             for (const result of mergedQueryResults){
@@ -134,6 +146,10 @@ function DataQueriesProvider(props) {
         profileResults,
         logQueries,
         logResults,
+        alertsQueries,
+        alertsResults,
+        silencesQueries,
+        silencesResults,
         refetchAll,
         queryOptions?.enabled,
         usageMetrics

package/dist/cjs/runtime/DataQueriesProvider/model.js

@@ -55,13 +55,21 @@ function useQueryType() {
     const { data: logQueries, isLoading: isLogQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
         'LogQuery'
     ]);
+    const { data: alertsQueryPlugins, isLoading: isAlertsQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
+        'AlertsQuery'
+    ]);
+    const { data: silencesQueryPlugins, isLoading: isSilencesQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
+        'SilencesQuery'
+    ]);
     // For example, `map: {"TimeSeriesQuery":["PrometheusTimeSeriesQuery"],"TraceQuery":["TempoTraceQuery"]}`
     const queryTypeMap = (0, _react.useMemo)(()=>{
         const map = {
             TimeSeriesQuery: [],
             TraceQuery: [],
             ProfileQuery: [],
-            LogQuery: []
+            LogQuery: [],
+            AlertsQuery: [],
+            SilencesQuery: []
         };
         if (timeSeriesQueryPlugins) {
             timeSeriesQueryPlugins.forEach((plugin)=>{
@@ -83,12 +91,24 @@ function useQueryType() {
                 map[plugin.kind]?.push(plugin.spec.name);
             });
         }
+        if (alertsQueryPlugins) {
+            alertsQueryPlugins.forEach((plugin)=>{
+                map[plugin.kind]?.push(plugin.spec.name);
+            });
+        }
+        if (silencesQueryPlugins) {
+            silencesQueryPlugins.forEach((plugin)=>{
+                map[plugin.kind]?.push(plugin.spec.name);
+            });
+        }
         return map;
     }, [
         timeSeriesQueryPlugins,
         traceQueryPlugins,
         profileQueryPlugins,
-        logQueries
+        logQueries,
+        alertsQueryPlugins,
+        silencesQueryPlugins
     ]);
     const getQueryType = (0, _react.useCallback)((pluginKind)=>{
         const isLoading = (pluginKind)=>{
@@ -101,8 +121,12 @@ function useQueryType() {
                     return isProfileQueryPluginLoading;
                 case 'LokiLogQuery':
                     return isLogQueryPluginLoading;
+                case 'AlertmanagerAlertsQuery':
+                    return isAlertsQueryPluginLoading;
+                case 'AlertmanagerSilencesQuery':
+                    return isSilencesQueryPluginLoading;
             }
-            return isTraceQueryPluginLoading || isTimeSeriesQueryLoading || isProfileQueryPluginLoading || isLogQueryPluginLoading;
+            return isTraceQueryPluginLoading || isTimeSeriesQueryLoading || isProfileQueryPluginLoading || isLogQueryPluginLoading || isAlertsQueryPluginLoading || isSilencesQueryPluginLoading;
         };
         if (isLoading(pluginKind)) {
             return undefined;
@@ -118,7 +142,9 @@ function useQueryType() {
         isTimeSeriesQueryLoading,
         isTraceQueryPluginLoading,
         isProfileQueryPluginLoading,
-        isLogQueryPluginLoading
+        isLogQueryPluginLoading,
+        isAlertsQueryPluginLoading,
+        isSilencesQueryPluginLoading
     ]);
     return getQueryType;
 }

package/dist/cjs/runtime/UsageMetricsProvider.js

@@ -35,7 +35,7 @@ _export(exports, {
     }
 });
 const _jsxruntime = require("react/jsx-runtime");
-const _core = require("@perses-dev/core");
+const _client = require("@perses-dev/client");
 const _react = require("react");
 const UsageMetricsContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
 const useUsageMetricsContext = ()=>{
@@ -70,7 +70,7 @@ const useUsageMetrics = ()=>{
     };
 };
 const submitMetrics = async (stats)=>{
-    await (0, _core.fetch)(`${stats.apiPrefix ?? ''}/api/v1/view`, {
+    await (0, _client.fetch)(`${stats.apiPrefix ?? ''}/api/v1/view`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json'