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

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");
@@ -52,60 +54,61 @@ function useDataQueriesContext() {
 }
 function useDataQueries(queryType) {
     const ctx = useDataQueriesContext();
+    // Filter query definitions based on the specified query type
+    const filteredQueryDefinitions = ctx.queryDefinitions.filter((definition)=>definition.kind === queryType);
     // Filter the query results based on the specified query type
     const filteredQueryResults = ctx.queryResults.filter((queryResult)=>queryResult?.definition?.kind === queryType);
     // Filter the errors based on the specified query type
     const filteredErrors = ctx.errors.filter((errors, index)=>ctx.queryResults[index]?.definition?.kind === queryType);
     // Create a new context object with the filtered results and errors
-    const filteredCtx = {
+    return {
+        queryDefinitions: filteredQueryDefinitions,
         queryResults: filteredQueryResults,
         isFetching: filteredQueryResults.some((result)=>result.isFetching),
         isLoading: filteredQueryResults.some((result)=>result.isLoading),
         refetchAll: ctx.refetchAll,
         errors: filteredErrors
     };
-    return filteredCtx;
 }
 function DataQueriesProvider(props) {
     const { definitions, options, children, queryOptions } = props;
-    // Returns a query kind, for example "TimeSeriesQuery" = getQueryType("PrometheusTimeSeriesQuery")
-    const getQueryType = (0, _model.useQueryType)();
-    const queryDefinitions = definitions.map((definition)=>{
-        const type = getQueryType(definition.kind);
-        return {
-            kind: type,
-            spec: {
-                plugin: definition
-            }
-        };
-    });
     const usageMetrics = (0, _UsageMetricsProvider.useUsageMetrics)();
     // Filter definitions for time series query and other future query plugins
-    const timeSeriesQueries = queryDefinitions.filter((definition)=>definition.kind === 'TimeSeriesQuery');
+    const timeSeriesQueries = definitions.filter((definition)=>definition.kind === 'TimeSeriesQuery');
     const timeSeriesResults = (0, _timeseriesqueries.useTimeSeriesQueries)(timeSeriesQueries, options, queryOptions);
-    const traceQueries = queryDefinitions.filter((definition)=>definition.kind === 'TraceQuery');
+    const traceQueries = definitions.filter((definition)=>definition.kind === 'TraceQuery');
     const traceResults = (0, _tracequeries.useTraceQueries)(traceQueries);
-    const profileQueries = queryDefinitions.filter((definition)=>definition.kind === 'ProfileQuery');
+    const profileQueries = definitions.filter((definition)=>definition.kind === 'ProfileQuery');
     const profileResults = (0, _profilequeries.useProfileQueries)(profileQueries);
-    const logQueries = queryDefinitions.filter((definition)=>definition.kind === 'LogQuery');
+    const logQueries = definitions.filter((definition)=>definition.kind === 'LogQuery');
     const logResults = (0, _logqueries.useLogQueries)(logQueries);
+    const alertsQueries = definitions.filter((definition)=>definition.kind === 'AlertsQuery');
+    const alertsResults = (0, _alertsqueries.useAlertsQueries)(alertsQueries);
+    const silencesQueries = definitions.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){
@@ -119,6 +122,7 @@ function DataQueriesProvider(props) {
             }
         }
         return {
+            queryDefinitions: definitions,
             queryResults: mergedQueryResults,
             isFetching: mergedQueryResults.some((result)=>result.isFetching),
             isLoading: mergedQueryResults.some((result)=>result.isLoading),
@@ -126,16 +130,21 @@ function DataQueriesProvider(props) {
             errors: mergedQueryResults.map((result)=>result.error)
         };
     }, [
+        alertsQueries,
+        alertsResults,
+        logQueries,
+        logResults,
+        profileQueries,
+        profileResults,
+        silencesQueries,
+        silencesResults,
         timeSeriesQueries,
         timeSeriesResults,
         traceQueries,
         traceResults,
-        profileQueries,
-        profileResults,
-        logQueries,
-        logResults,
-        refetchAll,
+        definitions,
         queryOptions?.enabled,
+        refetchAll,
         usageMetrics
     ]);
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(DataQueriesContext.Provider, {

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

@@ -14,22 +14,12 @@
 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 transformQueryResults () {
+Object.defineProperty(exports, "transformQueryResults", {
+    enumerable: true,
+    get: function() {
         return transformQueryResults;
-    },
-    get useQueryType () {
-        return useQueryType;
     }
 });
-const _react = require("react");
-const _pluginregistry = require("../plugin-registry");
 function transformQueryResults(results, definitions) {
     return results.map(({ data, isFetching, isLoading, refetch, error }, i)=>{
         return {
@@ -42,83 +32,3 @@ function transformQueryResults(results, definitions) {
         };
     });
 }
-function useQueryType() {
-    const { data: timeSeriesQueryPlugins, isLoading: isTimeSeriesQueryLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'TimeSeriesQuery'
-    ]);
-    const { data: traceQueryPlugins, isLoading: isTraceQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'TraceQuery'
-    ]);
-    const { data: profileQueryPlugins, isLoading: isProfileQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'ProfileQuery'
-    ]);
-    const { data: logQueries, isLoading: isLogQueryPluginLoading } = (0, _pluginregistry.useListPluginMetadata)([
-        'LogQuery'
-    ]);
-    // For example, `map: {"TimeSeriesQuery":["PrometheusTimeSeriesQuery"],"TraceQuery":["TempoTraceQuery"]}`
-    const queryTypeMap = (0, _react.useMemo)(()=>{
-        const map = {
-            TimeSeriesQuery: [],
-            TraceQuery: [],
-            ProfileQuery: [],
-            LogQuery: []
-        };
-        if (timeSeriesQueryPlugins) {
-            timeSeriesQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (traceQueryPlugins) {
-            traceQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (profileQueryPlugins) {
-            profileQueryPlugins.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        if (logQueries) {
-            logQueries.forEach((plugin)=>{
-                map[plugin.kind]?.push(plugin.spec.name);
-            });
-        }
-        return map;
-    }, [
-        timeSeriesQueryPlugins,
-        traceQueryPlugins,
-        profileQueryPlugins,
-        logQueries
-    ]);
-    const getQueryType = (0, _react.useCallback)((pluginKind)=>{
-        const isLoading = (pluginKind)=>{
-            switch(pluginKind){
-                case 'PrometheusTimeSeriesQuery':
-                    return isTimeSeriesQueryLoading;
-                case 'TempoTraceQuery':
-                    return isTraceQueryPluginLoading;
-                case 'PyroscopeProfileQuery':
-                    return isProfileQueryPluginLoading;
-                case 'LokiLogQuery':
-                    return isLogQueryPluginLoading;
-            }
-            return isTraceQueryPluginLoading || isTimeSeriesQueryLoading || isProfileQueryPluginLoading || isLogQueryPluginLoading;
-        };
-        if (isLoading(pluginKind)) {
-            return undefined;
-        }
-        for(const queryType in queryTypeMap){
-            if (queryTypeMap[queryType]?.includes(pluginKind)) {
-                return queryType;
-            }
-        }
-        throw new Error(`Unable to determine the query type: ${pluginKind}`);
-    }, [
-        queryTypeMap,
-        isTimeSeriesQueryLoading,
-        isTraceQueryPluginLoading,
-        isProfileQueryPluginLoading,
-        isLogQueryPluginLoading
-    ]);
-    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'

package/dist/cjs/runtime/alerts-queries.js

@@ -0,0 +1,101 @@
+// 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 ALERTS_QUERY_KEY () {
+        return ALERTS_QUERY_KEY;
+    },
+    get useAlertsQueries () {
+        return useAlertsQueries;
+    }
+});
+const _reactquery = require("@tanstack/react-query");
+const _datasources = require("./datasources");
+const _pluginregistry = require("./plugin-registry");
+const _variables = require("./variables");
+const _utils = require("./utils");
+const ALERTS_QUERY_KEY = 'AlertsQuery';
+function useAlertsQueries(definitions) {
+    const { getPlugin } = (0, _pluginregistry.usePluginRegistry)();
+    const context = useAlertsQueryContext();
+    const pluginLoaderResponse = (0, _pluginregistry.usePlugins)('AlertsQuery', definitions.map((d)=>({
+            kind: d.spec.plugin.kind
+        })));
+    return (0, _reactquery.useQueries)({
+        queries: definitions.map((definition, idx)=>{
+            const plugin = pluginLoaderResponse[idx]?.data;
+            const { queryEnabled, queryKey } = getQueryOptions({
+                context,
+                definition,
+                plugin
+            });
+            const alertsQueryKind = definition?.spec?.plugin?.kind;
+            return {
+                enabled: queryEnabled,
+                queryKey: queryKey,
+                refetchOnMount: false,
+                refetchOnWindowFocus: false,
+                refetchOnReconnect: false,
+                staleTime: 60_000,
+                queryFn: async ({ signal })=>{
+                    const plugin = await getPlugin({
+                        kind: ALERTS_QUERY_KEY,
+                        name: alertsQueryKind
+                    });
+                    const data = await plugin.getAlertsData(definition.spec.plugin.spec, context, signal);
+                    return data;
+                }
+            };
+        })
+    });
+}
+function getQueryOptions({ plugin, definition, context }) {
+    const { variableState } = context;
+    const dependencies = plugin?.dependsOn ? plugin.dependsOn(definition.spec.plugin.spec, context) : {};
+    const variableDependencies = dependencies?.variables;
+    const filteredVariabledState = (0, _utils.filterVariableStateMap)(variableState, variableDependencies);
+    const variablesValueKey = (0, _utils.getVariableValuesKey)(filteredVariabledState);
+    // Note: no absoluteTimeRange in query key since alerts are current state
+    const queryKey = [
+        'query',
+        ALERTS_QUERY_KEY,
+        definition,
+        variablesValueKey
+    ];
+    let waitToLoad = false;
+    if (variableDependencies) {
+        waitToLoad = variableDependencies.some((v)=>variableState[v]?.loading);
+    }
+    const queryEnabled = plugin !== undefined && !waitToLoad;
+    return {
+        queryKey,
+        queryEnabled
+    };
+}
+function useAlertsQueryContext() {
+    const variableState = (0, _variables.useAllVariableValues)();
+    const datasourceStore = (0, _datasources.useDatasourceStore)();
+    return {
+        variableState,
+        datasourceStore
+    };
+}

package/dist/cjs/runtime/annotations.js

@@ -0,0 +1,148 @@
+// 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 ANNOTATION_KEY () {
+        return ANNOTATION_KEY;
+    },
+    get useAnnotationData () {
+        return useAnnotationData;
+    },
+    get useAnnotations () {
+        return useAnnotations;
+    }
+});
+const _reactquery = require("@tanstack/react-query");
+const _pluginregistry = require("./plugin-registry");
+const _TimeRangeProvider = require("./TimeRangeProvider");
+const _variables = require("./variables");
+const _datasources = require("./datasources");
+const _utils = require("./utils");
+const ANNOTATION_KEY = 'Annotation';
+function useAnnotationContext() {
+    const { absoluteTimeRange } = (0, _TimeRangeProvider.useTimeRange)();
+    const variableState = (0, _variables.useAllVariableValues)();
+    const datasourceStore = (0, _datasources.useDatasourceStore)();
+    return {
+        variableState,
+        datasourceStore,
+        absoluteTimeRange
+    };
+}
+function getQueryOptions({ plugin, definition, context }) {
+    const { variableState, absoluteTimeRange } = context;
+    const dependencies = plugin?.dependsOn ? plugin.dependsOn(definition.plugin.spec, context) : {};
+    const variableDependencies = dependencies?.variables;
+    const filteredVariableState = (0, _utils.filterVariableStateMap)(variableState, variableDependencies);
+    const variablesValueKey = (0, _utils.getVariableValuesKey)(filteredVariableState);
+    const queryKey = [
+        ANNOTATION_KEY,
+        definition,
+        absoluteTimeRange,
+        variablesValueKey
+    ];
+    let waitToLoad = false;
+    if (variableDependencies) {
+        waitToLoad = variableDependencies.some((v)=>variableState[v]?.loading);
+    }
+    const queryEnabled = plugin !== undefined && !waitToLoad;
+    return {
+        queryKey,
+        queryEnabled
+    };
+}
+function useAnnotations(definitions) {
+    const { getPlugin } = (0, _pluginregistry.usePluginRegistry)();
+    const context = useAnnotationContext();
+    const pluginLoaderResponse = (0, _pluginregistry.usePlugins)('Annotation', definitions.map((d)=>({
+            kind: d.plugin.kind
+        })));
+    // useQueries() handles data fetching from query plugins
+    return (0, _reactquery.useQueries)({
+        queries: definitions.map((definition, idx)=>{
+            const plugin = pluginLoaderResponse[idx]?.data;
+            const { queryEnabled, queryKey } = getQueryOptions({
+                context,
+                definition,
+                plugin
+            });
+            const annotationKind = definition?.plugin?.kind;
+            return {
+                enabled: queryEnabled,
+                queryKey: queryKey,
+                refetchOnMount: false,
+                refetchOnWindowFocus: false,
+                refetchOnReconnect: false,
+                staleTime: Infinity,
+                queryFn: async ({ signal })=>{
+                    const plugin = await getPlugin({
+                        kind: ANNOTATION_KEY,
+                        name: annotationKind
+                    });
+                    const data = await plugin.getAnnotationData(definition.plugin.spec, context, signal);
+                    return data;
+                }
+            };
+        })
+    });
+}
+function useAnnotationData(spec) {
+    const { data: annotationPlugin } = (0, _pluginregistry.usePlugin)('Annotation', spec.plugin.kind);
+    const datasourceStore = (0, _datasources.useDatasourceStore)();
+    const allVariables = (0, _variables.useAllVariableValues)();
+    const { absoluteTimeRange: timeRange } = (0, _TimeRangeProvider.useTimeRange)();
+    const variablePluginCtx = {
+        absoluteTimeRange: timeRange,
+        datasourceStore,
+        variableState: allVariables
+    };
+    let dependsOnVariables = Object.keys(allVariables); // Default to all variables
+    if (annotationPlugin?.dependsOn) {
+        const dependencies = annotationPlugin.dependsOn(spec.plugin.spec, variablePluginCtx);
+        dependsOnVariables = dependencies.variables ? dependencies.variables : dependsOnVariables;
+    }
+    const variables = (0, _variables.useAllVariableValues)(dependsOnVariables);
+    let waitToLoad = false;
+    if (dependsOnVariables) {
+        waitToLoad = dependsOnVariables.some((v)=>variables[v]?.loading);
+    }
+    const variablesValueKey = (0, _utils.getVariableValuesKey)(variables);
+    return (0, _reactquery.useQuery)({
+        queryKey: [
+            'annotation',
+            spec,
+            timeRange,
+            variablesValueKey
+        ],
+        queryFn: async ({ signal })=>{
+            const resp = await annotationPlugin?.getAnnotationData(spec.plugin.spec, {
+                ...variablePluginCtx,
+                variableState: variables
+            }, signal);
+            if (!resp?.length) {
+                return [];
+            }
+            return resp;
+        },
+        enabled: !!annotationPlugin || waitToLoad
+    });
+}

package/dist/cjs/runtime/index.js

@@ -14,6 +14,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./annotations"), exports);
 _export_star(require("./builtin-variables"), exports);
 _export_star(require("./datasources"), exports);
 _export_star(require("./plugin-registry"), exports);
@@ -22,9 +23,10 @@ _export_star(require("./TimeRangeProvider"), exports);
 _export_star(require("./time-series-queries"), exports);
 _export_star(require("./trace-queries"), exports);
 _export_star(require("./profile-queries"), exports);
+_export_star(require("./alerts-queries"), exports);
+_export_star(require("./silences-queries"), exports);
 _export_star(require("./item-actions"), exports);
 _export_star(require("./DataQueriesProvider"), exports);
-_export_star(require("./QueryCountProvider"), exports);
 _export_star(require("./RouterProvider"), exports);
 _export_star(require("./UsageMetricsProvider"), exports);
 function _export_star(from, to) {

package/dist/cjs/runtime/item-actions.js

@@ -21,7 +21,7 @@ Object.defineProperty(exports, "executeAction", {
     }
 });
 const _components = require("@perses-dev/components");
-const _core = require("@perses-dev/core");
+const _client = require("@perses-dev/client");
 const BODY_METHODS = new Set([
     'POST',
     'PUT',
@@ -174,7 +174,7 @@ function buildWebhookHeaders(action) {
                 body = bodyResult.text;
             }
             // Make the request
-            const response = await (0, _core.fetch)(urlResult.text, {
+            const response = await (0, _client.fetch)(urlResult.text, {
                 method: action.method,
                 headers: buildWebhookHeaders(action),
                 body: body
@@ -239,7 +239,7 @@ function buildWebhookHeaders(action) {
             body = bodyResult.text;
         }
         // Make the request
-        const response = await (0, _core.fetch)(urlResult.text, {
+        const response = await (0, _client.fetch)(urlResult.text, {
             method: action.method,
             headers: buildWebhookHeaders(action),
             body: body

package/dist/cjs/runtime/log-queries.js

@@ -62,7 +62,10 @@ function useLogQueries(definitions) {
                 refetchOnReconnect: false,
                 staleTime: Infinity,
                 queryFn: async ({ signal })=>{
-                    const plugin = await getPlugin(LOG_QUERY_KEY, logQueryKind);
+                    const plugin = await getPlugin({
+                        kind: LOG_QUERY_KEY,
+                        name: logQueryKind
+                    });
                     const data = await plugin.getLogData(definition.spec.plugin.spec, context, signal);
                     return data;
                 },

package/dist/cjs/runtime/plugin-registry.js

@@ -63,7 +63,10 @@ function usePlugin(pluginType, kind, options) {
             pluginType,
             kind
         ],
-        queryFn: ()=>getPlugin(pluginType, kind),
+        queryFn: ()=>getPlugin({
+                kind: pluginType,
+                name: kind
+            }),
         ...options
     });
 }
@@ -84,7 +87,10 @@ function usePlugins(pluginType, plugins) {
                     pluginType,
                     kind
                 ],
-                queryFn: ()=>getPlugin(pluginType, kind)
+                queryFn: ()=>getPlugin({
+                        kind: pluginType,
+                        name: kind
+                    })
             };
         })
     });
@@ -115,7 +121,10 @@ function usePluginBuiltinVariableDefinitions() {
             const datasourceNames = new Set(datasources.map((datasource)=>datasource.spec.name));
             const result = [];
             for (const name of datasourceNames){
-                const plugin = await getPlugin('Datasource', name);
+                const plugin = await getPlugin({
+                    kind: 'Datasource',
+                    name
+                });
                 if (plugin.getBuiltinVariableDefinitions) {
                     plugin.getBuiltinVariableDefinitions().forEach((definition)=>result.push(definition));
                 }

package/dist/cjs/runtime/profile-queries.js

@@ -59,7 +59,10 @@ function useProfileQueries(definitions) {
                 refetchOnReconnect: false,
                 staleTime: Infinity,
                 queryFn: async ({ signal })=>{
-                    const plugin = await getPlugin(PROFILE_QUERY_KEY, profileQueryKind);
+                    const plugin = await getPlugin({
+                        kind: PROFILE_QUERY_KEY,
+                        name: profileQueryKind
+                    });
                     const data = await plugin.getProfileData(definition.spec.plugin.spec, context, signal);
                     return data;
                 },