From b77fe7db3e885edca14c862f362e2bbd43f0e498 Mon Sep 17 00:00:00 2001
From: Chris Baumbauer <cab@cabnetworks.net>
Date: Sat, 6 Apr 2019 02:02:39 +0000
Subject: [PATCH] Add Knative metrics to Prometheus
---
.../serverless/components/area.vue | 146 ++++++++++++++++++
.../components/function_details.vue | 54 ++++++-
.../serverless/components/function_row.vue | 5 +
.../serverless/components/functions.vue | 44 +++---
.../components/missing_prometheus.vue | 63 ++++++++
.../javascripts/serverless/constants.js | 3 +
.../serverless/serverless_bundle.js | 125 ++++-----------
.../services/get_functions_service.js | 11 --
.../javascripts/serverless/store/actions.js | 113 ++++++++++++++
.../javascripts/serverless/store/getters.js | 10 ++
.../javascripts/serverless/store/index.js | 18 +++
.../serverless/store/mutation_types.js | 9 ++
.../javascripts/serverless/store/mutations.js | 38 +++++
.../javascripts/serverless/store/state.js | 13 ++
.../stores/serverless_details_store.js | 11 --
.../serverless/stores/serverless_store.js | 29 ----
app/assets/javascripts/serverless/utils.js | 23 +++
.../serverless/functions_controller.rb | 23 ++-
.../projects/serverless/functions_finder.rb | 28 +++-
app/models/serverless/function.rb | 26 ++++
.../projects/serverless/service_entity.rb | 7 +
.../serverless/functions/index.html.haml | 5 +-
.../serverless/functions/show.html.haml | 11 +-
changelogs/unreleased/knative-prometheus.yml | 5 +
config/prometheus/common_metrics.yml | 10 ++
config/routes/project.rb | 6 +-
...326164045_import_common_metrics_knative.rb | 17 ++
db/schema.rb | 2 +-
.../img/function-details-loaded.png | Bin 0 -> 93515 bytes
doc/user/project/clusters/serverless/index.md | 20 +++
.../queries/knative_invocation_query.rb | 39 +++++
locale/gitlab.pot | 18 ++-
.../serverless/functions_controller_spec.rb | 9 ++
.../projects/serverless/functions_spec.rb | 2 +-
.../serverless/functions_finder_spec.rb | 32 +++-
.../serverless/components/area_spec.js | 121 +++++++++++++++
.../components/environment_row_spec.js | 41 ++---
.../components/function_details_spec.js | 113 ++++++++++++++
.../components/function_row_spec.js | 13 +-
.../serverless/components/functions_spec.js | 113 +++++++++-----
.../components/missing_prometheus_spec.js | 37 +++++
.../serverless/components/pod_box_spec.js | 22 +++
.../serverless/components/url_spec.js | 20 +--
spec/javascripts/serverless/mock_data.js | 57 +++++++
.../serverless/store/actions_spec.js | 88 +++++++++++
.../serverless/store/getters_spec.js | 43 ++++++
.../serverless/store/mutations_spec.js | 86 +++++++++++
.../stores/serverless_store_spec.js | 36 -----
spec/javascripts/serverless/utils.js | 20 +++
.../queries/knative_invocation_query_spec.rb | 26 ++++
spec/models/serverless/function_spec.rb | 21 +++
spec/support/helpers/prometheus_helpers.rb | 4 +
52 files changed, 1516 insertions(+), 320 deletions(-)
create mode 100644 app/assets/javascripts/serverless/components/area.vue
create mode 100644 app/assets/javascripts/serverless/components/missing_prometheus.vue
create mode 100644 app/assets/javascripts/serverless/constants.js
delete mode 100644 app/assets/javascripts/serverless/services/get_functions_service.js
create mode 100644 app/assets/javascripts/serverless/store/actions.js
create mode 100644 app/assets/javascripts/serverless/store/getters.js
create mode 100644 app/assets/javascripts/serverless/store/index.js
create mode 100644 app/assets/javascripts/serverless/store/mutation_types.js
create mode 100644 app/assets/javascripts/serverless/store/mutations.js
create mode 100644 app/assets/javascripts/serverless/store/state.js
delete mode 100644 app/assets/javascripts/serverless/stores/serverless_details_store.js
delete mode 100644 app/assets/javascripts/serverless/stores/serverless_store.js
create mode 100644 app/assets/javascripts/serverless/utils.js
create mode 100644 app/models/serverless/function.rb
create mode 100644 changelogs/unreleased/knative-prometheus.yml
create mode 100644 db/migrate/20190326164045_import_common_metrics_knative.rb
create mode 100644 doc/user/project/clusters/serverless/img/function-details-loaded.png
create mode 100644 lib/gitlab/prometheus/queries/knative_invocation_query.rb
create mode 100644 spec/javascripts/serverless/components/area_spec.js
create mode 100644 spec/javascripts/serverless/components/function_details_spec.js
create mode 100644 spec/javascripts/serverless/components/missing_prometheus_spec.js
create mode 100644 spec/javascripts/serverless/components/pod_box_spec.js
create mode 100644 spec/javascripts/serverless/store/actions_spec.js
create mode 100644 spec/javascripts/serverless/store/getters_spec.js
create mode 100644 spec/javascripts/serverless/store/mutations_spec.js
delete mode 100644 spec/javascripts/serverless/stores/serverless_store_spec.js
create mode 100644 spec/javascripts/serverless/utils.js
create mode 100644 spec/lib/gitlab/prometheus/queries/knative_invocation_query_spec.rb
create mode 100644 spec/models/serverless/function_spec.rb
diff --git a/app/assets/javascripts/serverless/components/area.vue b/app/assets/javascripts/serverless/components/area.vue
new file mode 100644
index 0000000000000..32c9d6eccb83e
--- /dev/null
+++ b/app/assets/javascripts/serverless/components/area.vue
@@ -0,0 +1,146 @@
+<script>
+import { GlAreaChart } from '@gitlab/ui/dist/charts';
+import { debounceByAnimationFrame } from '~/lib/utils/common_utils';
+import dateFormat from 'dateformat';
+import { X_INTERVAL } from '../constants';
+import { validateGraphData } from '../utils';
+
+let debouncedResize;
+
+export default {
+ components: {
+ GlAreaChart,
+ },
+ inheritAttrs: false,
+ props: {
+ graphData: {
+ type: Object,
+ required: true,
+ validator: validateGraphData,
+ },
+ containerWidth: {
+ type: Number,
+ required: true,
+ },
+ },
+ data() {
+ return {
+ tooltipPopoverTitle: '',
+ tooltipPopoverContent: '',
+ width: this.containerWidth,
+ };
+ },
+ computed: {
+ chartData() {
+ return this.graphData.queries.reduce((accumulator, query) => {
+ accumulator[query.unit] = query.result.reduce((acc, res) => acc.concat(res.values), []);
+ return accumulator;
+ }, {});
+ },
+ extractTimeData() {
+ return this.chartData.requests.map(data => data.time);
+ },
+ generateSeries() {
+ return {
+ name: 'Invocations',
+ type: 'line',
+ data: this.chartData.requests.map(data => [data.time, data.value]),
+ symbolSize: 0,
+ };
+ },
+ getInterval() {
+ const { result } = this.graphData.queries[0];
+
+ if (result.length === 0) {
+ return 1;
+ }
+
+ const split = result[0].values.reduce(
+ (acc, pair) => (pair.value > acc ? pair.value : acc),
+ 1,
+ );
+
+ return split < X_INTERVAL ? split : X_INTERVAL;
+ },
+ chartOptions() {
+ return {
+ xAxis: {
+ name: 'time',
+ type: 'time',
+ axisLabel: {
+ formatter: date => dateFormat(date, 'h:MM TT'),
+ },
+ data: this.extractTimeData,
+ nameTextStyle: {
+ padding: [18, 0, 0, 0],
+ },
+ },
+ yAxis: {
+ name: this.yAxisLabel,
+ nameTextStyle: {
+ padding: [0, 0, 36, 0],
+ },
+ splitNumber: this.getInterval,
+ },
+ legend: {
+ formatter: this.xAxisLabel,
+ },
+ series: this.generateSeries,
+ };
+ },
+ xAxisLabel() {
+ return this.graphData.queries.map(query => query.label).join(', ');
+ },
+ yAxisLabel() {
+ const [query] = this.graphData.queries;
+ return `${this.graphData.y_label} (${query.unit})`;
+ },
+ },
+ watch: {
+ containerWidth: 'onResize',
+ },
+ beforeDestroy() {
+ window.removeEventListener('resize', debouncedResize);
+ },
+ created() {
+ debouncedResize = debounceByAnimationFrame(this.onResize);
+ window.addEventListener('resize', debouncedResize);
+ },
+ methods: {
+ formatTooltipText(params) {
+ const [seriesData] = params.seriesData;
+ this.tooltipPopoverTitle = dateFormat(params.value, 'dd mmm yyyy, h:MMTT');
+ this.tooltipPopoverContent = `${this.yAxisLabel}: ${seriesData.value[1]}`;
+ },
+ onResize() {
+ const { width } = this.$refs.areaChart.$el.getBoundingClientRect();
+ this.width = width;
+ },
+ },
+};
+</script>
+
+<template>
+ <div class="prometheus-graph">
+ <div class="prometheus-graph-header">
+ <h5 ref="graphTitle" class="prometheus-graph-title">{{ graphData.title }}</h5>
+ <div ref="graphWidgets" class="prometheus-graph-widgets"><slot></slot></div>
+ </div>
+ <gl-area-chart
+ ref="areaChart"
+ v-bind="$attrs"
+ :data="[]"
+ :option="chartOptions"
+ :format-tooltip-text="formatTooltipText"
+ :width="width"
+ :include-legend-avg-max="false"
+ >
+ <template slot="tooltipTitle">
+ {{ tooltipPopoverTitle }}
+ </template>
+ <template slot="tooltipContent">
+ {{ tooltipPopoverContent }}
+ </template>
+ </gl-area-chart>
+ </div>
+</template>
diff --git a/app/assets/javascripts/serverless/components/function_details.vue b/app/assets/javascripts/serverless/components/function_details.vue
index 4f89ad691290e..b8906cfca4e2a 100644
--- a/app/assets/javascripts/serverless/components/function_details.vue
+++ b/app/assets/javascripts/serverless/components/function_details.vue
@@ -1,39 +1,77 @@
<script>
+import _ from 'underscore';
+import { mapState, mapActions, mapGetters } from 'vuex';
import PodBox from './pod_box.vue';
import Url from './url.vue';
+import AreaChart from './area.vue';
+import MissingPrometheus from './missing_prometheus.vue';
export default {
components: {
PodBox,
Url,
+ AreaChart,
+ MissingPrometheus,
},
props: {
func: {
type: Object,
required: true,
},
+ hasPrometheus: {
+ type: Boolean,
+ required: false,
+ default: false,
+ },
+ clustersPath: {
+ type: String,
+ required: true,
+ },
+ helpPath: {
+ type: String,
+ required: true,
+ },
+ },
+ data() {
+ return {
+ elWidth: 0,
+ };
},
computed: {
name() {
return this.func.name;
},
description() {
- return this.func.description;
+ return _.isString(this.func.description) ? this.func.description : '';
},
funcUrl() {
return this.func.url;
},
podCount() {
- return this.func.podcount || 0;
+ return Number(this.func.podcount) || 0;
},
+ ...mapState(['graphData', 'hasPrometheusData']),
+ ...mapGetters(['hasPrometheusMissingData']),
+ },
+ created() {
+ this.fetchMetrics({
+ metricsPath: this.func.metricsUrl,
+ hasPrometheus: this.hasPrometheus,
+ });
+ },
+ mounted() {
+ this.elWidth = this.$el.clientWidth;
+ },
+ methods: {
+ ...mapActions(['fetchMetrics']),
},
};
</script>
<template>
<section id="serverless-function-details">
- <h3>{{ name }}</h3>
- <div class="append-bottom-default">
+ <h3 class="serverless-function-name">{{ name }}</h3>
+ <div class="append-bottom-default serverless-function-description">
<div v-for="(line, index) in description.split('\n')" :key="index">{{ line }}</div>
</div>
<url :uri="funcUrl" />
@@ -52,5 +90,13 @@ export default {
</p>
</div>
<div v-else><p>No pods loaded at this time.</p></div>
+
+ <area-chart v-if="hasPrometheusData" :graph-data="graphData" :container-width="elWidth" />
+ <missing-prometheus
+ v-if="!hasPrometheus || hasPrometheusMissingData"
+ :help-path="helpPath"
+ :clusters-path="clustersPath"
+ :missing-data="hasPrometheusMissingData"
+ />
</section>
</template>
diff --git a/app/assets/javascripts/serverless/components/function_row.vue b/app/assets/javascripts/serverless/components/function_row.vue
index 773d18781fda3..4b3bb078eae4b 100644
--- a/app/assets/javascripts/serverless/components/function_row.vue
+++ b/app/assets/javascripts/serverless/components/function_row.vue
@@ -1,4 +1,5 @@
<script>
+import _ from 'underscore';
import Timeago from '~/vue_shared/components/time_ago_tooltip.vue';
import Url from './url.vue';
import { visitUrl } from '~/lib/utils/url_utility';
@@ -19,6 +20,10 @@ export default {
return this.func.name;
},
description() {
+ if (!_.isString(this.func.description)) {
+ return '';
+ }
+
const desc = this.func.description.split('\n');
if (desc.length > 1) {
return desc[1];
diff --git a/app/assets/javascripts/serverless/components/functions.vue b/app/assets/javascripts/serverless/components/functions.vue
index 4bde409f9066c..f9b4e78956380 100644
--- a/app/assets/javascripts/serverless/components/functions.vue
+++ b/app/assets/javascripts/serverless/components/functions.vue
@@ -1,5 +1,6 @@
<script>
-import { GlSkeletonLoading } from '@gitlab/ui';
+import { mapState, mapActions, mapGetters } from 'vuex';
+import { GlLoadingIcon } from '@gitlab/ui';
import FunctionRow from './function_row.vue';
import EnvironmentRow from './environment_row.vue';
import EmptyState from './empty_state.vue';
@@ -9,14 +10,9 @@ export default {
EnvironmentRow,
FunctionRow,
EmptyState,
- GlSkeletonLoading,
+ GlLoadingIcon,
},
props: {
- functions: {
- type: Object,
- required: true,
- default: () => ({}),
- },
installed: {
type: Boolean,
required: true,
@@ -29,17 +25,23 @@ export default {
type: String,
required: true,
},
- loadingData: {
- type: Boolean,
- required: false,
- default: true,
- },
- hasFunctionData: {
- type: Boolean,
- required: false,
- default: true,
+ statusPath: {
+ type: String,
+ required: true,
},
},
+ computed: {
+ ...mapState(['isLoading', 'hasFunctionData']),
+ ...mapGetters(['getFunctions']),
+ },
+ created() {
+ this.fetchFunctions({
+ functionsPath: this.statusPath,
+ });
+ },
+ methods: {
+ ...mapActions(['fetchFunctions']),
+ },
};
</script>
@@ -47,14 +49,16 @@ export default {
<section id="serverless-functions">
<div v-if="installed">
<div v-if="hasFunctionData">
- <template v-if="loadingData">
- <div v-for="j in 3" :key="j" class="gl-responsive-table-row"><gl-skeleton-loading /></div>
- </template>
+ <gl-loading-icon
+ v-if="isLoading"
+ :size="2"
+ class="prepend-top-default append-bottom-default"
+ />
<template v-else>
<div class="groups-list-tree-container">
<ul class="content-list group-list-tree">
<environment-row
- v-for="(env, index) in functions"
+ v-for="(env, index) in getFunctions"
:key="index"
:env="env"
:env-name="index"
diff --git a/app/assets/javascripts/serverless/components/missing_prometheus.vue b/app/assets/javascripts/serverless/components/missing_prometheus.vue
new file mode 100644
index 0000000000000..6c19434f20209
--- /dev/null
+++ b/app/assets/javascripts/serverless/components/missing_prometheus.vue
@@ -0,0 +1,63 @@
+<script>
+import { GlButton, GlLink } from '@gitlab/ui';
+import { s__ } from '../../locale';
+
+export default {
+ components: {
+ GlButton,
+ GlLink,
+ },
+ props: {
+ clustersPath: {
+ type: String,
+ required: true,
+ },
+ helpPath: {
+ type: String,
+ required: true,
+ },
+ missingData: {
+ type: Boolean,
+ required: true,
+ },
+ },
+ computed: {
+ missingStateClass() {
+ return this.missingData ? 'missing-prometheus-state' : 'empty-prometheus-state';
+ },
+ prometheusHelpPath() {
+ return `${this.helpPath}#prometheus-support`;
+ },
+ description() {
+ return this.missingData
+ ? s__(`ServerlessDetails|Invocation metrics loading or not available at this time.`)
+ : s__(
+ `ServerlessDetails|Function invocation metrics require Prometheus to be installed first.`,
+ );
+ },
+ },
+};
+</script>
+
+<template>
+ <div class="row" :class="missingStateClass">
+ <div class="col-12">
+ <div class="text-content">
+ <h4 class="state-title text-left">{{ s__(`ServerlessDetails|Invocations`) }}</h4>
+ <p class="state-description">
+ {{ description }}
+ <gl-link :href="prometheusHelpPath">{{
+ s__(`ServerlessDetails|More information`)
+ }}</gl-link
+ >.
+ </p>
+
+ <div v-if="!missingData" class="text-left">
+ <gl-button :href="clustersPath" variant="success">
+ {{ s__('ServerlessDetails|Install Prometheus') }}
+ </gl-button>
+ </div>
+ </div>
+ </div>
+ </div>
+</template>
diff --git a/app/assets/javascripts/serverless/constants.js b/app/assets/javascripts/serverless/constants.js
new file mode 100644
index 0000000000000..35f77205f2ce9
--- /dev/null
+++ b/app/assets/javascripts/serverless/constants.js
@@ -0,0 +1,3 @@
+export const MAX_REQUESTS = 3; // max number of times to retry
+
+export const X_INTERVAL = 5; // Reflects the number of verticle bars on the x-axis
diff --git a/app/assets/javascripts/serverless/serverless_bundle.js b/app/assets/javascripts/serverless/serverless_bundle.js
index 47a510d5fb597..2d3f086ffeedf 100644
--- a/app/assets/javascripts/serverless/serverless_bundle.js
+++ b/app/assets/javascripts/serverless/serverless_bundle.js
@@ -1,13 +1,7 @@
-import Visibility from 'visibilityjs';
import Vue from 'vue';
-import { s__ } from '../locale';
-import Flash from '../flash';
-import Poll from '../lib/utils/poll';
-import ServerlessStore from './stores/serverless_store';
-import ServerlessDetailsStore from './stores/serverless_details_store';
-import GetFunctionsService from './services/get_functions_service';
import Functions from './components/functions.vue';
import FunctionDetails from './components/function_details.vue';
+import { createStore } from './store';
export default class Serverless {
constructor() {
@@ -19,10 +13,12 @@ export default class Serverless {
serviceUrl,
serviceNamespace,
servicePodcount,
+ serviceMetricsUrl,
+ prometheus,
+ clustersPath,
+ helpPath,
} = document.querySelector('.js-serverless-function-details-page').dataset;
const el = document.querySelector('#js-serverless-function-details');
- this.store = new ServerlessDetailsStore();
- const { store } = this;
const service = {
name: serviceName,
@@ -31,20 +27,19 @@ export default class Serverless {
url: serviceUrl,
namespace: serviceNamespace,
podcount: servicePodcount,
+ metricsUrl: serviceMetricsUrl,
};
- this.store.updateDetailedFunction(service);
this.functionDetails = new Vue({
el,
- data() {
- return {
- state: store.state,
- };
- },
+ store: createStore(),
render(createElement) {
return createElement(FunctionDetails, {
props: {
- func: this.state.functionDetail,
+ func: service,
+ hasPrometheus: prometheus !== undefined,
+ clustersPath,
+ helpPath,
},
});
},
@@ -54,95 +49,27 @@ export default class Serverless {
'.js-serverless-functions-page',
).dataset;
- this.service = new GetFunctionsService(statusPath);
- this.knativeInstalled = installed !== undefined;
- this.store = new ServerlessStore(this.knativeInstalled, clustersPath, helpPath);
- this.initServerless();
- this.functionLoadCount = 0;
-
- if (statusPath && this.knativeInstalled) {
- this.initPolling();
- }
- }
- }
-
- initServerless() {
- const { store } = this;
- const el = document.querySelector('#js-serverless-functions');
-
- this.functions = new Vue({
- el,
- data() {
- return {
- state: store.state,
- };
- },
- render(createElement) {
- return createElement(Functions, {
- props: {
- functions: this.state.functions,
- installed: this.state.installed,
- clustersPath: this.state.clustersPath,
- helpPath: this.state.helpPath,
- loadingData: this.state.loadingData,
- hasFunctionData: this.state.hasFunctionData,
- },
- });
- },
- });
- }
-
- initPolling() {
- this.poll = new Poll({
- resource: this.service,
- method: 'fetchData',
- successCallback: data => this.handleSuccess(data),
- errorCallback: () => Serverless.handleError(),
- });
-
- if (!Visibility.hidden()) {
- this.poll.makeRequest();
- } else {
- this.service
- .fetchData()
- .then(data => this.handleSuccess(data))
- .catch(() => Serverless.handleError());
- }
-
- Visibility.change(() => {
- if (!Visibility.hidden() && !this.destroyed) {
- this.poll.restart();
- } else {
- this.poll.stop();
- }
- });
- }
-
- handleSuccess(data) {
- if (data.status === 200) {
- this.store.updateFunctionsFromServer(data.data);
- this.store.updateLoadingState(false);
- } else if (data.status === 204) {
- /* Time out after 3 attempts to retrieve data */
- this.functionLoadCount += 1;
- if (this.functionLoadCount === 3) {
- this.poll.stop();
- this.store.toggleNoFunctionData();
- }
+ const el = document.querySelector('#js-serverless-functions');
+ this.functions = new Vue({
+ el,
+ store: createStore(),
+ render(createElement) {
+ return createElement(Functions, {
+ props: {
+ installed: installed !== undefined,
+ clustersPath,
+ helpPath,
+ statusPath,
+ },
+ });
+ },
+ });
}
}
- static handleError() {
- Flash(s__('Serverless|An error occurred while retrieving serverless components'));
- }
-
destroy() {
this.destroyed = true;
- if (this.poll) {
- this.poll.stop();
- }
-
this.functions.$destroy();
this.functionDetails.$destroy();
}
diff --git a/app/assets/javascripts/serverless/services/get_functions_service.js b/app/assets/javascripts/serverless/services/get_functions_service.js
deleted file mode 100644
index 303b42dc66ccc..0000000000000
--- a/app/assets/javascripts/serverless/services/get_functions_service.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import axios from '~/lib/utils/axios_utils';
-
-export default class GetFunctionsService {
- constructor(endpoint) {
- this.endpoint = endpoint;
- }
-
- fetchData() {
- return axios.get(this.endpoint);
- }
-}
diff --git a/app/assets/javascripts/serverless/store/actions.js b/app/assets/javascripts/serverless/store/actions.js
new file mode 100644
index 0000000000000..826501c90224c
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/actions.js
@@ -0,0 +1,113 @@
+import * as types from './mutation_types';
+import axios from '~/lib/utils/axios_utils';
+import statusCodes from '~/lib/utils/http_status';
+import { backOff } from '~/lib/utils/common_utils';
+import createFlash from '~/flash';
+import { MAX_REQUESTS } from '../constants';
+
+export const requestFunctionsLoading = ({ commit }) => commit(types.REQUEST_FUNCTIONS_LOADING);
+export const receiveFunctionsSuccess = ({ commit }, data) =>
+ commit(types.RECEIVE_FUNCTIONS_SUCCESS, data);
+export const receiveFunctionsNoDataSuccess = ({ commit }) =>
+ commit(types.RECEIVE_FUNCTIONS_NODATA_SUCCESS);
+export const receiveFunctionsError = ({ commit }, error) =>
+ commit(types.RECEIVE_FUNCTIONS_ERROR, error);
+
+export const receiveMetricsSuccess = ({ commit }, data) =>
+ commit(types.RECEIVE_METRICS_SUCCESS, data);
+export const receiveMetricsNoPrometheus = ({ commit }) =>
+ commit(types.RECEIVE_METRICS_NO_PROMETHEUS);
+export const receiveMetricsNoDataSuccess = ({ commit }, data) =>
+ commit(types.RECEIVE_METRICS_NODATA_SUCCESS, data);
+export const receiveMetricsError = ({ commit }, error) =>
+ commit(types.RECEIVE_METRICS_ERROR, error);
+
+export const fetchFunctions = ({ dispatch }, { functionsPath }) => {
+ let retryCount = 0;
+
+ dispatch('requestFunctionsLoading');
+
+ backOff((next, stop) => {
+ axios
+ .get(functionsPath)
+ .then(response => {
+ if (response.status === statusCodes.NO_CONTENT) {
+ retryCount += 1;
+ if (retryCount < MAX_REQUESTS) {
+ next();
+ } else {
+ stop(null);
+ }
+ } else {
+ stop(response.data);
+ }
+ })
+ .catch(stop);
+ })
+ .then(data => {
+ if (data !== null) {
+ dispatch('receiveFunctionsSuccess', data);
+ } else {
+ dispatch('receiveFunctionsNoDataSuccess');
+ }
+ })
+ .catch(error => {
+ dispatch('receiveFunctionsError', error);
+ createFlash(error);
+ });
+};
+
+export const fetchMetrics = ({ dispatch }, { metricsPath, hasPrometheus }) => {
+ let retryCount = 0;
+
+ if (!hasPrometheus) {
+ dispatch('receiveMetricsNoPrometheus');
+ return;
+ }
+
+ backOff((next, stop) => {
+ axios
+ .get(metricsPath)
+ .then(response => {
+ if (response.status === statusCodes.NO_CONTENT) {
+ retryCount += 1;
+ if (retryCount < MAX_REQUESTS) {
+ next();
+ } else {
+ dispatch('receiveMetricsNoDataSuccess');
+ stop(null);
+ }
+ } else {
+ stop(response.data);
+ }
+ })
+ .catch(stop);
+ })
+ .then(data => {
+ if (data === null) {
+ return;
+ }
+
+ const updatedMetric = data.metrics;
+ const queries = data.metrics.queries.map(query => ({
+ ...query,
+ result: query.result.map(result => ({
+ ...result,
+ values: result.values.map(([timestamp, value]) => ({
+ time: new Date(timestamp * 1000).toISOString(),
+ value: Number(value),
+ })),
+ })),
+ }));
+
+ updatedMetric.queries = queries;
+ dispatch('receiveMetricsSuccess', updatedMetric);
+ })
+ .catch(error => {
+ dispatch('receiveMetricsError', error);
+ createFlash(error);
+ });
+};
+
+// prevent babel-plugin-rewire from generating an invalid default during karma tests
+export default () => {};
diff --git a/app/assets/javascripts/serverless/store/getters.js b/app/assets/javascripts/serverless/store/getters.js
new file mode 100644
index 0000000000000..071f663d9d2dd
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/getters.js
@@ -0,0 +1,10 @@
+import { translate } from '../utils';
+
+export const hasPrometheusMissingData = state => state.hasPrometheus && !state.hasPrometheusData;
+
+// Convert the function list into a k/v grouping based on the environment scope
+
+export const getFunctions = state => translate(state.functions);
+
+// prevent babel-plugin-rewire from generating an invalid default during karma tests
+export default () => {};
diff --git a/app/assets/javascripts/serverless/store/index.js b/app/assets/javascripts/serverless/store/index.js
new file mode 100644
index 0000000000000..5f72060633ebe
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/index.js
@@ -0,0 +1,18 @@
+import Vue from 'vue';
+import Vuex from 'vuex';
+import * as actions from './actions';
+import * as getters from './getters';
+import mutations from './mutations';
+import createState from './state';
+
+Vue.use(Vuex);
+
+export const createStore = () =>
+ new Vuex.Store({
+ actions,
+ getters,
+ mutations,
+ state: createState(),
+ });
+
+export default createStore();
diff --git a/app/assets/javascripts/serverless/store/mutation_types.js b/app/assets/javascripts/serverless/store/mutation_types.js
new file mode 100644
index 0000000000000..25b2f7ac38aa2
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/mutation_types.js
@@ -0,0 +1,9 @@
+export const REQUEST_FUNCTIONS_LOADING = 'REQUEST_FUNCTIONS_LOADING';
+export const RECEIVE_FUNCTIONS_SUCCESS = 'RECEIVE_FUNCTIONS_SUCCESS';
+export const RECEIVE_FUNCTIONS_NODATA_SUCCESS = 'RECEIVE_FUNCTIONS_NODATA_SUCCESS';
+export const RECEIVE_FUNCTIONS_ERROR = 'RECEIVE_FUNCTIONS_ERROR';
+
+export const RECEIVE_METRICS_NO_PROMETHEUS = 'RECEIVE_METRICS_NO_PROMETHEUS';
+export const RECEIVE_METRICS_SUCCESS = 'RECEIVE_METRICS_SUCCESS';
+export const RECEIVE_METRICS_NODATA_SUCCESS = 'RECEIVE_METRICS_NODATA_SUCCESS';
+export const RECEIVE_METRICS_ERROR = 'RECEIVE_METRICS_ERROR';
diff --git a/app/assets/javascripts/serverless/store/mutations.js b/app/assets/javascripts/serverless/store/mutations.js
new file mode 100644
index 0000000000000..991f32a275d03
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/mutations.js
@@ -0,0 +1,38 @@
+import * as types from './mutation_types';
+
+export default {
+ [types.REQUEST_FUNCTIONS_LOADING](state) {
+ state.isLoading = true;
+ },
+ [types.RECEIVE_FUNCTIONS_SUCCESS](state, data) {
+ state.functions = data;
+ state.isLoading = false;
+ state.hasFunctionData = true;
+ },
+ [types.RECEIVE_FUNCTIONS_NODATA_SUCCESS](state) {
+ state.isLoading = false;
+ state.hasFunctionData = false;
+ },
+ [types.RECEIVE_FUNCTIONS_ERROR](state, error) {
+ state.error = error;
+ state.hasFunctionData = false;
+ state.isLoading = false;
+ },
+ [types.RECEIVE_METRICS_SUCCESS](state, data) {
+ state.isLoading = false;
+ state.hasPrometheusData = true;
+ state.graphData = data;
+ },
+ [types.RECEIVE_METRICS_NODATA_SUCCESS](state) {
+ state.isLoading = false;
+ state.hasPrometheusData = false;
+ },
+ [types.RECEIVE_METRICS_ERROR](state, error) {
+ state.hasPrometheusData = false;
+ state.error = error;
+ },
+ [types.RECEIVE_METRICS_NO_PROMETHEUS](state) {
+ state.hasPrometheusData = false;
+ state.hasPrometheus = false;
+ },
+};
diff --git a/app/assets/javascripts/serverless/store/state.js b/app/assets/javascripts/serverless/store/state.js
new file mode 100644
index 0000000000000..afc3f37d7ba3f
--- /dev/null
+++ b/app/assets/javascripts/serverless/store/state.js
@@ -0,0 +1,13 @@
+export default () => ({
+ error: null,
+ isLoading: true,
+
+ // functions
+ functions: [],
+ hasFunctionData: true,
+
+ // function_details
+ hasPrometheus: true,
+ hasPrometheusData: false,
+ graphData: {},
+});
diff --git a/app/assets/javascripts/serverless/stores/serverless_details_store.js b/app/assets/javascripts/serverless/stores/serverless_details_store.js
deleted file mode 100644
index 5394d2cded1b0..0000000000000
--- a/app/assets/javascripts/serverless/stores/serverless_details_store.js
+++ /dev/null
@@ -1,11 +0,0 @@
-export default class ServerlessDetailsStore {
- constructor() {
- this.state = {
- functionDetail: {},
- };
- }
-
- updateDetailedFunction(func) {
- this.state.functionDetail = func;
- }
-}
diff --git a/app/assets/javascripts/serverless/stores/serverless_store.js b/app/assets/javascripts/serverless/stores/serverless_store.js
deleted file mode 100644
index 816d55a03f94d..0000000000000
--- a/app/assets/javascripts/serverless/stores/serverless_store.js
+++ /dev/null
@@ -1,29 +0,0 @@
-export default class ServerlessStore {
- constructor(knativeInstalled = false, clustersPath, helpPath) {
- this.state = {
- functions: {},
- hasFunctionData: true,
- loadingData: true,
- installed: knativeInstalled,
- clustersPath,
- helpPath,
- };
- }
-
- updateFunctionsFromServer(upstreamFunctions = []) {
- this.state.functions = upstreamFunctions.reduce((rv, func) => {
- const envs = rv;
- envs[func.environment_scope] = (rv[func.environment_scope] || []).concat([func]);
-
- return envs;
- }, {});
- }
-
- updateLoadingState(loadingData) {
- this.state.loadingData = loadingData;
- }
-
- toggleNoFunctionData() {
- this.state.hasFunctionData = false;
- }
-}
diff --git a/app/assets/javascripts/serverless/utils.js b/app/assets/javascripts/serverless/utils.js
new file mode 100644
index 0000000000000..8b9e96ce9aa69
--- /dev/null
+++ b/app/assets/javascripts/serverless/utils.js
@@ -0,0 +1,23 @@
+// Validate that the object coming in has valid query details and results
+export const validateGraphData = data =>
+ data.queries &&
+ Array.isArray(data.queries) &&
+ data.queries.filter(query => {
+ if (Array.isArray(query.result)) {
+ return query.result.filter(res => Array.isArray(res.values)).length === query.result.length;
+ }
+
+ return false;
+ }).length === data.queries.length;
+
+export const translate = functions =>
+ functions.reduce(
+ (acc, func) =>
+ Object.assign(acc, {
+ [func.environment_scope]: (acc[func.environment_scope] || []).concat([func]),
+ }),
+ {},
+ );
+
+// prevent babel-plugin-rewire from generating an invalid default during karma tests
+export default () => {};
diff --git a/app/controllers/projects/serverless/functions_controller.rb b/app/controllers/projects/serverless/functions_controller.rb
index 39eca10134fe0..8c3d141c888c1 100644
--- a/app/controllers/projects/serverless/functions_controller.rb
+++ b/app/controllers/projects/serverless/functions_controller.rb
@@ -7,19 +7,14 @@ class FunctionsController < Projects::ApplicationController
before_action :authorize_read_cluster!
- INDEX_PRIMING_INTERVAL = 15_000
- INDEX_POLLING_INTERVAL = 60_000
-
def index
respond_to do |format|
format.json do
functions = finder.execute
if functions.any?
- Gitlab::PollingInterval.set_header(response, interval: INDEX_POLLING_INTERVAL)
render json: serialize_function(functions)
else
- Gitlab::PollingInterval.set_header(response, interval: INDEX_PRIMING_INTERVAL)
head :no_content
end
end
@@ -33,6 +28,8 @@ def index
def show
@service = serialize_function(finder.service(params[:environment_id], params[:id]))
+ @prometheus = finder.has_prometheus?(params[:environment_id])
+
return not_found if @service.nil?
respond_to do |format|
@@ -44,10 +41,24 @@ def show
end
end
+ def metrics
+ respond_to do |format|
+ format.json do
+ metrics = finder.invocation_metrics(params[:environment_id], params[:id])
+
+ if metrics.nil?
+ head :no_content
+ else
+ render json: metrics
+ end
+ end
+ end
+ end
+
private
def finder
- Projects::Serverless::FunctionsFinder.new(project.clusters)
+ Projects::Serverless::FunctionsFinder.new(project)
end
def serialize_function(function)
diff --git a/app/finders/projects/serverless/functions_finder.rb b/app/finders/projects/serverless/functions_finder.rb
index 2f2816a4a0830..d9802598c6405 100644
--- a/app/finders/projects/serverless/functions_finder.rb
+++ b/app/finders/projects/serverless/functions_finder.rb
@@ -3,8 +3,9 @@
module Projects
module Serverless
class FunctionsFinder
- def initialize(clusters)
- @clusters = clusters
+ def initialize(project)
+ @clusters = project.clusters
+ @project = project
end
def execute
@@ -19,6 +20,23 @@ def service(environment_scope, name)
knative_service(environment_scope, name)&.first
end
+ def invocation_metrics(environment_scope, name)
+ return unless prometheus_adapter&.can_query?
+
+ cluster = clusters_with_knative_installed.preload_knative.find do |c|
+ environment_scope == c.environment_scope
+ end
+
+ func = ::Serverless::Function.new(@project, name, cluster.platform_kubernetes&.actual_namespace)
+ prometheus_adapter.query(:knative_invocation, func)
+ end
+
+ def has_prometheus?(environment_scope)
+ clusters_with_knative_installed.preload_knative.to_a.any? do |cluster|
+ environment_scope == cluster.environment_scope && cluster.application_prometheus_available?
+ end
+ end
+
private
def knative_service(environment_scope, name)
@@ -55,6 +73,12 @@ def add_metadata(cluster, services)
def clusters_with_knative_installed
@clusters.with_knative_installed
end
+
+ # rubocop: disable CodeReuse/ServiceClass
+ def prometheus_adapter
+ @prometheus_adapter ||= ::Prometheus::AdapterService.new(@project).prometheus_adapter
+ end
+ # rubocop: enable CodeReuse/ServiceClass
end
end
end
diff --git a/app/models/serverless/function.rb b/app/models/serverless/function.rb
new file mode 100644
index 0000000000000..5d4f8e0c9e296
--- /dev/null
+++ b/app/models/serverless/function.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Serverless
+ class Function
+ attr_accessor :name, :namespace
+
+ def initialize(project, name, namespace)
+ @project = project
+ @name = name
+ @namespace = namespace
+ end
+
+ def id
+ @project.id.to_s + "/" + @name + "/" + @namespace
+ end
+
+ def self.find_by_id(id)
+ array = id.split("/")
+ project = Project.find_by_id(array[0])
+ name = array[1]
+ namespace = array[2]
+
+ self.new(project, name, namespace)
+ end
+ end
+end
diff --git a/app/serializers/projects/serverless/service_entity.rb b/app/serializers/projects/serverless/service_entity.rb
index c98dc1a1c4aa9..a46f8af146619 100644
--- a/app/serializers/projects/serverless/service_entity.rb
+++ b/app/serializers/projects/serverless/service_entity.rb
@@ -32,6 +32,13 @@ class ServiceEntity < Grape::Entity
service.dig('podcount')
end
+ expose :metrics_url do |service|
+ project_serverless_metrics_path(
+ request.project,
+ service.dig('environment_scope'),
+ service.dig('metadata', 'name')) + ".json"
+ end
+
expose :created_at do |service|
service.dig('metadata', 'creationTimestamp')
end
diff --git a/app/views/projects/serverless/functions/index.html.haml b/app/views/projects/serverless/functions/index.html.haml
index 635580eac5c44..9c69aedfbfcb4 100644
--- a/app/views/projects/serverless/functions/index.html.haml
+++ b/app/views/projects/serverless/functions/index.html.haml
@@ -5,7 +5,10 @@
- status_path = project_serverless_functions_path(@project, format: :json)
- clusters_path = project_clusters_path(@project)
-.serverless-functions-page.js-serverless-functions-page{ data: { status_path: status_path, installed: @installed, clusters_path: clusters_path, help_path: help_page_path('user/project/clusters/serverless/index') } }
+.serverless-functions-page.js-serverless-functions-page{ data: { status_path: status_path,
+ installed: @installed,
+ clusters_path: clusters_path,
+ help_path: help_page_path('user/project/clusters/serverless/index') } }
%div{ class: [container_class, ('limit-container-width' unless fluid_layout)] }
.js-serverless-functions-notice
diff --git a/app/views/projects/serverless/functions/show.html.haml b/app/views/projects/serverless/functions/show.html.haml
index 29737b7014ae6..d1fe208ce60f6 100644
--- a/app/views/projects/serverless/functions/show.html.haml
+++ b/app/views/projects/serverless/functions/show.html.haml
@@ -1,14 +1,19 @@
- @no_container = true
- @content_class = "limit-container-width" unless fluid_layout
+- clusters_path = project_clusters_path(@project)
+- help_path = help_page_path('user/project/clusters/serverless/index')
- add_to_breadcrumbs('Serverless', project_serverless_functions_path(@project))
- page_title @service[:name]
-.serverless-function-details-page.js-serverless-function-details-page{ data: { service: @service.as_json } }
+.serverless-function-details-page.js-serverless-function-details-page{ data: { service: @service.as_json,
+ prometheus: @prometheus,
+ clusters_path: clusters_path,
+ help_path: help_path } }
+
%div{ class: [container_class, ('limit-container-width' unless fluid_layout)] }
- .top-area.adjust
- .serverless-function-details#js-serverless-function-details
+ .serverless-function-details#js-serverless-function-details
.js-serverless-function-notice
.flash-container
diff --git a/changelogs/unreleased/knative-prometheus.yml b/changelogs/unreleased/knative-prometheus.yml
new file mode 100644
index 0000000000000..e24f53b72252d
--- /dev/null
+++ b/changelogs/unreleased/knative-prometheus.yml
@@ -0,0 +1,5 @@
+---
+title: Add Knative metrics to Prometheus
+merge_request: 24663
+author: Chris Baumbauer <cab@cabnetworks.net>
+type: added
diff --git a/config/prometheus/common_metrics.yml b/config/prometheus/common_metrics.yml
index 9bdaf1575e9d7..884868c63362c 100644
--- a/config/prometheus/common_metrics.yml
+++ b/config/prometheus/common_metrics.yml
@@ -259,3 +259,13 @@
label: Pod average
unit: "cores"
track: canary
+ - title: "Knative function invocations"
+ y_label: "Invocations"
+ required_metrics:
+ - istio_revision_request_count
+ weight: 1
+ queries:
+ - id: system_metrics_knative_function_invocation_count
+ query_range: 'floor(sum(rate(istio_revision_request_count{destination_configuration="%{function_name}", destination_namespace="%{kube_namespace}"}[1m])*30))'
+ label: invocations / minute
+ unit: requests
diff --git a/config/routes/project.rb b/config/routes/project.rb
index 1cb8f331f6f5d..93d168fc595fd 100644
--- a/config/routes/project.rb
+++ b/config/routes/project.rb
@@ -252,7 +252,11 @@
end
namespace :serverless do
- get '/functions/:environment_id/:id', to: 'functions#show'
+ scope :functions do
+ get '/:environment_id/:id', to: 'functions#show'
+ get '/:environment_id/:id/metrics', to: 'functions#metrics', as: :metrics
+ end
+
resources :functions, only: [:index]
end
diff --git a/db/migrate/20190326164045_import_common_metrics_knative.rb b/db/migrate/20190326164045_import_common_metrics_knative.rb
new file mode 100644
index 0000000000000..340ec1e1f750e
--- /dev/null
+++ b/db/migrate/20190326164045_import_common_metrics_knative.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class ImportCommonMetricsKnative < ActiveRecord::Migration[5.0]
+ include Gitlab::Database::MigrationHelpers
+
+ require Rails.root.join('db/importers/common_metrics_importer.rb')
+
+ DOWNTIME = false
+
+ def up
+ Importers::CommonMetricsImporter.new.execute
+ end
+
+ def down
+ # no-op
+ end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 1a50c6efbc7ae..ca5b04e810a0c 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
#
# It's strongly recommended that you check this file into your version control system.
-ActiveRecord::Schema.define(version: 20190325165127) do
+ActiveRecord::Schema.define(version: 20190326164045) do
# These are extensions that must be enabled in order to support this database
enable_extension "plpgsql"
diff --git a/doc/user/project/clusters/serverless/img/function-details-loaded.png b/doc/user/project/clusters/serverless/img/function-details-loaded.png
new file mode 100644
index 0000000000000000000000000000000000000000..34465c5c08761c4cf6a177fd1868413676802d20
GIT binary patch
literal 93515
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	J
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
literal 0
HcmV?d00001
diff --git a/doc/user/project/clusters/serverless/index.md b/doc/user/project/clusters/serverless/index.md
index b72083e85df5a..5b7e9ef906fed 100644
--- a/doc/user/project/clusters/serverless/index.md
+++ b/doc/user/project/clusters/serverless/index.md
@@ -301,3 +301,23 @@ The second to last line, labeled **Service domain** contains the URL for the dep
browser to see the app live.
+
+## Function details
+
+Go to the **Operations > Serverless** page and click on one of the function
+rows to bring up the function details page.
+
+
+
+The pod count will give you the number of pods running the serverless function instances on a given cluster.
+
+### Prometheus support
+
+For the Knative function invocations to appear,
+[Prometheus must be installed](../index.md#installing-applications).
+
+Once Prometheus is installed, a message may appear indicating that the metrics data _is
+loading or is not available at this time._ It will appear upon the first access of the
+page, but should go away after a few seconds. If the message does not disappear, then it
+is possible that GitLab is unable to connect to the Prometheus instance running on the
+cluster.
diff --git a/lib/gitlab/prometheus/queries/knative_invocation_query.rb b/lib/gitlab/prometheus/queries/knative_invocation_query.rb
new file mode 100644
index 0000000000000..2691abe46d628
--- /dev/null
+++ b/lib/gitlab/prometheus/queries/knative_invocation_query.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gitlab
+ module Prometheus
+ module Queries
+ class KnativeInvocationQuery < BaseQuery
+ include QueryAdditionalMetrics
+
+ def query(serverless_function_id)
+ PrometheusMetric
+ .find_by_identifier(:system_metrics_knative_function_invocation_count)
+ .to_query_metric.tap do |q|
+ q.queries[0][:result] = run_query(q.queries[0][:query_range], context(serverless_function_id))
+ end
+ end
+
+ protected
+
+ def context(function_id)
+ function = Serverless::Function.find_by_id(function_id)
+ {
+ function_name: function.name,
+ kube_namespace: function.namespace
+ }
+ end
+
+ def run_query(query, context)
+ query %= context
+ client_query_range(query, start: 8.hours.ago.to_f, stop: Time.now.to_f)
+ end
+
+ def self.transform_reactive_result(result)
+ result[:metrics] = result.delete :data
+ result
+ end
+ end
+ end
+ end
+end
diff --git a/locale/gitlab.pot b/locale/gitlab.pot
index 4e756cf2095f3..711baff9f9acb 100644
--- a/locale/gitlab.pot
+++ b/locale/gitlab.pot
@@ -7238,9 +7238,24 @@ msgstr ""
msgid "Serverless"
msgstr ""
+msgid "ServerlessDetails|Function invocation metrics require Prometheus to be installed first."
+msgstr ""
+
+msgid "ServerlessDetails|Install Prometheus"
+msgstr ""
+
+msgid "ServerlessDetails|Invocation metrics loading or not available at this time."
+msgstr ""
+
+msgid "ServerlessDetails|Invocations"
+msgstr ""
+
msgid "ServerlessDetails|Kubernetes Pods"
msgstr ""
+msgid "ServerlessDetails|More information"
+msgstr ""
+
msgid "ServerlessDetails|Number of Kubernetes pods in use over time based on necessity."
msgstr ""
@@ -7256,9 +7271,6 @@ msgstr ""
msgid "Serverless| In order to start using functions as a service, you must first install Knative on your Kubernetes cluster."
msgstr ""
-msgid "Serverless|An error occurred while retrieving serverless components"
-msgstr ""
-
msgid "Serverless|Getting started with serverless"
msgstr ""
diff --git a/spec/controllers/projects/serverless/functions_controller_spec.rb b/spec/controllers/projects/serverless/functions_controller_spec.rb
index 276cf340962b8..782f5f272d921 100644
--- a/spec/controllers/projects/serverless/functions_controller_spec.rb
+++ b/spec/controllers/projects/serverless/functions_controller_spec.rb
@@ -76,6 +76,15 @@ def params(opts = {})
end
end
+ describe 'GET #metrics' do
+ context 'invalid data' do
+ it 'has a bad function name' do
+ get :metrics, params: params({ format: :json, environment_id: "*", id: "foo" })
+ expect(response).to have_gitlab_http_status(204)
+ end
+ end
+ end
+
describe 'GET #index with data', :use_clean_rails_memory_store_caching do
before do
stub_kubeclient_service_pods
diff --git a/spec/features/projects/serverless/functions_spec.rb b/spec/features/projects/serverless/functions_spec.rb
index aa71669de988d..e14934b16724d 100644
--- a/spec/features/projects/serverless/functions_spec.rb
+++ b/spec/features/projects/serverless/functions_spec.rb
@@ -50,7 +50,7 @@
end
it 'sees an empty listing of serverless functions' do
- expect(page).to have_selector('.gl-responsive-table-row')
+ expect(page).to have_selector('.empty-state')
end
end
end
diff --git a/spec/finders/projects/serverless/functions_finder_spec.rb b/spec/finders/projects/serverless/functions_finder_spec.rb
index 35279906854bb..3ad38207da4a2 100644
--- a/spec/finders/projects/serverless/functions_finder_spec.rb
+++ b/spec/finders/projects/serverless/functions_finder_spec.rb
@@ -4,6 +4,7 @@
describe Projects::Serverless::FunctionsFinder do
include KubernetesHelpers
+ include PrometheusHelpers
include ReactiveCachingHelpers
let(:user) { create(:user) }
@@ -24,12 +25,12 @@
describe 'retrieve data from knative' do
it 'does not have knative installed' do
- expect(described_class.new(project.clusters).execute).to be_empty
+ expect(described_class.new(project).execute).to be_empty
end
context 'has knative installed' do
let!(:knative) { create(:clusters_applications_knative, :installed, cluster: cluster) }
- let(:finder) { described_class.new(project.clusters) }
+ let(:finder) { described_class.new(project) }
it 'there are no functions' do
expect(finder.execute).to be_empty
@@ -58,13 +59,36 @@
expect(result).not_to be_empty
expect(result["metadata"]["name"]).to be_eql(cluster.project.name)
end
+
+ it 'has metrics', :use_clean_rails_memory_store_caching do
+ end
+ end
+
+ context 'has prometheus' do
+ let(:prometheus_adapter) { double('prometheus_adapter', can_query?: true) }
+ let!(:knative) { create(:clusters_applications_knative, :installed, cluster: cluster) }
+ let!(:prometheus) { create(:clusters_applications_prometheus, :installed, cluster: cluster) }
+ let(:finder) { described_class.new(project) }
+
+ before do
+ allow(finder).to receive(:prometheus_adapter).and_return(prometheus_adapter)
+ allow(prometheus_adapter).to receive(:query).and_return(prometheus_empty_body('matrix'))
+ end
+
+ it 'is available' do
+ expect(finder.has_prometheus?("*")).to be true
+ end
+
+ it 'has query data' do
+ expect(finder.invocation_metrics("*", cluster.project.name)).not_to be_nil
+ end
end
end
describe 'verify if knative is installed' do
context 'knative is not installed' do
it 'does not have knative installed' do
- expect(described_class.new(project.clusters).installed?).to be false
+ expect(described_class.new(project).installed?).to be false
end
end
@@ -72,7 +96,7 @@
let!(:knative) { create(:clusters_applications_knative, :installed, cluster: cluster) }
it 'does have knative installed' do
- expect(described_class.new(project.clusters).installed?).to be true
+ expect(described_class.new(project).installed?).to be true
end
end
end
diff --git a/spec/javascripts/serverless/components/area_spec.js b/spec/javascripts/serverless/components/area_spec.js
new file mode 100644
index 0000000000000..2be6ac3d26889
--- /dev/null
+++ b/spec/javascripts/serverless/components/area_spec.js
@@ -0,0 +1,121 @@
+import { shallowMount } from '@vue/test-utils';
+import Area from '~/serverless/components/area.vue';
+import { mockNormalizedMetrics } from '../mock_data';
+
+describe('Area component', () => {
+ const mockWidgets = 'mockWidgets';
+ const mockGraphData = mockNormalizedMetrics;
+ let areaChart;
+
+ beforeEach(() => {
+ areaChart = shallowMount(Area, {
+ propsData: {
+ graphData: mockGraphData,
+ containerWidth: 0,
+ },
+ slots: {
+ default: mockWidgets,
+ },
+ });
+ });
+
+ afterEach(() => {
+ areaChart.destroy();
+ });
+
+ it('renders chart title', () => {
+ expect(areaChart.find({ ref: 'graphTitle' }).text()).toBe(mockGraphData.title);
+ });
+
+ it('contains graph widgets from slot', () => {
+ expect(areaChart.find({ ref: 'graphWidgets' }).text()).toBe(mockWidgets);
+ });
+
+ describe('methods', () => {
+ describe('formatTooltipText', () => {
+ const mockDate = mockNormalizedMetrics.queries[0].result[0].values[0].time;
+ const generateSeriesData = type => ({
+ seriesData: [
+ {
+ componentSubType: type,
+ value: [mockDate, 4],
+ },
+ ],
+ value: mockDate,
+ });
+
+ describe('series is of line type', () => {
+ beforeEach(() => {
+ areaChart.vm.formatTooltipText(generateSeriesData('line'));
+ });
+
+ it('formats tooltip title', () => {
+ expect(areaChart.vm.tooltipPopoverTitle).toBe('28 Feb 2019, 11:11AM');
+ });
+
+ it('formats tooltip content', () => {
+ expect(areaChart.vm.tooltipPopoverContent).toBe('Invocations (requests): 4');
+ });
+ });
+
+ it('verify default interval value of 1', () => {
+ expect(areaChart.vm.getInterval).toBe(1);
+ });
+ });
+
+ describe('onResize', () => {
+ const mockWidth = 233;
+
+ beforeEach(() => {
+ spyOn(Element.prototype, 'getBoundingClientRect').and.callFake(() => ({
+ width: mockWidth,
+ }));
+ areaChart.vm.onResize();
+ });
+
+ it('sets area chart width', () => {
+ expect(areaChart.vm.width).toBe(mockWidth);
+ });
+ });
+ });
+
+ describe('computed', () => {
+ describe('chartData', () => {
+ it('utilizes all data points', () => {
+ expect(Object.keys(areaChart.vm.chartData)).toEqual(['requests']);
+ expect(areaChart.vm.chartData.requests.length).toBe(2);
+ });
+
+ it('creates valid data', () => {
+ const data = areaChart.vm.chartData.requests;
+
+ expect(
+ data.filter(
+ datum => new Date(datum.time).getTime() > 0 && typeof datum.value === 'number',
+ ).length,
+ ).toBe(data.length);
+ });
+ });
+
+ describe('generateSeries', () => {
+ it('utilizes correct time data', () => {
+ expect(areaChart.vm.generateSeries.data).toEqual([
+ ['2019-02-28T11:11:38.756Z', 0],
+ ['2019-02-28T11:12:38.756Z', 0],
+ ]);
+ });
+ });
+
+ describe('xAxisLabel', () => {
+ it('constructs a label for the chart x-axis', () => {
+ expect(areaChart.vm.xAxisLabel).toBe('invocations / minute');
+ });
+ });
+
+ describe('yAxisLabel', () => {
+ it('constructs a label for the chart y-axis', () => {
+ expect(areaChart.vm.yAxisLabel).toBe('Invocations (requests)');
+ });
+ });
+ });
+});
diff --git a/spec/javascripts/serverless/components/environment_row_spec.js b/spec/javascripts/serverless/components/environment_row_spec.js
index bdf7a71491055..932d712dbecd5 100644
--- a/spec/javascripts/serverless/components/environment_row_spec.js
+++ b/spec/javascripts/serverless/components/environment_row_spec.js
@@ -1,81 +1,70 @@
-import Vue from 'vue';
-
import environmentRowComponent from '~/serverless/components/environment_row.vue';
-import mountComponent from 'spec/helpers/vue_mount_component_helper';
-import ServerlessStore from '~/serverless/stores/serverless_store';
+import { createLocalVue, shallowMount } from '@vue/test-utils';
import { mockServerlessFunctions, mockServerlessFunctionsDiffEnv } from '../mock_data';
+import { translate } from '~/serverless/utils';
-const createComponent = (env, envName) =>
- mountComponent(Vue.extend(environmentRowComponent), { env, envName });
+const createComponent = (localVue, env, envName) =>
+ shallowMount(environmentRowComponent, { localVue, propsData: { env, envName } }).vm;
describe('environment row component', () => {
describe('default global cluster case', () => {
+ let localVue;
let vm;
beforeEach(() => {
- const store = new ServerlessStore(false, '/cluster_path', 'help_path');
- store.updateFunctionsFromServer(mockServerlessFunctions);
- vm = createComponent(store.state.functions['*'], '*');
+ localVue = createLocalVue();
+ vm = createComponent(localVue, translate(mockServerlessFunctions)['*'], '*');
});
+ afterEach(() => vm.$destroy());
+
it('has the correct envId', () => {
expect(vm.envId).toEqual('env-global');
- vm.$destroy();
});
it('is open by default', () => {
expect(vm.isOpenClass).toEqual({ 'is-open': true });
- vm.$destroy();
});
it('generates correct output', () => {
- expect(vm.$el.querySelectorAll('li').length).toEqual(2);
expect(vm.$el.id).toEqual('env-global');
expect(vm.$el.classList.contains('is-open')).toBe(true);
expect(vm.$el.querySelector('div.title').innerHTML.trim()).toEqual('*');
-
- vm.$destroy();
});
it('opens and closes correctly', () => {
expect(vm.isOpen).toBe(true);
vm.toggleOpen();
- Vue.nextTick(() => {
- expect(vm.isOpen).toBe(false);
- });
- vm.$destroy();
+ expect(vm.isOpen).toBe(false);
});
});
describe('default named cluster case', () => {
let vm;
+ let localVue;
beforeEach(() => {
- const store = new ServerlessStore(false, '/cluster_path', 'help_path');
- store.updateFunctionsFromServer(mockServerlessFunctionsDiffEnv);
- vm = createComponent(store.state.functions.test, 'test');
+ localVue = createLocalVue();
+ vm = createComponent(localVue, translate(mockServerlessFunctionsDiffEnv).test, 'test');
});
+ afterEach(() => vm.$destroy());
+
it('has the correct envId', () => {
expect(vm.envId).toEqual('env-test');
- vm.$destroy();
});
it('is open by default', () => {
expect(vm.isOpenClass).toEqual({ 'is-open': true });
- vm.$destroy();
});
it('generates correct output', () => {
- expect(vm.$el.querySelectorAll('li').length).toEqual(1);
expect(vm.$el.id).toEqual('env-test');
expect(vm.$el.classList.contains('is-open')).toBe(true);
expect(vm.$el.querySelector('div.title').innerHTML.trim()).toEqual('test');
-
- vm.$destroy();
});
});
});
diff --git a/spec/javascripts/serverless/components/function_details_spec.js b/spec/javascripts/serverless/components/function_details_spec.js
new file mode 100644
index 0000000000000..a29d4a296ef90
--- /dev/null
+++ b/spec/javascripts/serverless/components/function_details_spec.js
@@ -0,0 +1,113 @@
+import Vuex from 'vuex';
+
+import functionDetailsComponent from '~/serverless/components/function_details.vue';
+import { createLocalVue, shallowMount } from '@vue/test-utils';
+import { createStore } from '~/serverless/store';
+
+describe('functionDetailsComponent', () => {
+ let localVue;
+ let component;
+ let store;
+
+ beforeEach(() => {
+ localVue = createLocalVue();
+ localVue.use(Vuex);
+
+ store = createStore();
+ });
+
+ afterEach(() => {
+ component.vm.$destroy();
+ });
+
+ describe('Verify base functionality', () => {
+ const serviceStub = {
+ name: 'test',
+ description: 'a description',
+ environment: '*',
+ url: 'http://service.com/test',
+ namespace: 'test-ns',
+ podcount: 0,
+ metricsUrl: '/metrics',
+ };
+
+ it('has a name, description, URL, and no pods loaded', () => {
+ component = shallowMount(functionDetailsComponent, {
+ localVue,
+ store,
+ propsData: {
+ func: serviceStub,
+ hasPrometheus: false,
+ clustersPath: '/clusters',
+ helpPath: '/help',
+ },
+ });
+
+ expect(
+ component.vm.$el.querySelector('.serverless-function-name').innerHTML.trim(),
+ ).toContain('test');
+
+ expect(
+ component.vm.$el.querySelector('.serverless-function-description').innerHTML.trim(),
+ ).toContain('a description');
+
+ expect(component.vm.$el.querySelector('p').innerHTML.trim()).toContain(
+ 'No pods loaded at this time.',
+ );
+ });
+
+ it('has a pods loaded', () => {
+ serviceStub.podcount = 1;
+
+ component = shallowMount(functionDetailsComponent, {
+ localVue,
+ store,
+ propsData: {
+ func: serviceStub,
+ hasPrometheus: false,
+ clustersPath: '/clusters',
+ helpPath: '/help',
+ },
+ });
+
+ expect(component.vm.$el.querySelector('p').innerHTML.trim()).toContain('1 pod in use');
+ });
+
+ it('has multiple pods loaded', () => {
+ serviceStub.podcount = 3;
+
+ component = shallowMount(functionDetailsComponent, {
+ localVue,
+ store,
+ propsData: {
+ func: serviceStub,
+ hasPrometheus: false,
+ clustersPath: '/clusters',
+ helpPath: '/help',
+ },
+ });
+
+ expect(component.vm.$el.querySelector('p').innerHTML.trim()).toContain('3 pods in use');
+ });
+
+ it('can support a missing description', () => {
+ serviceStub.description = null;
+
+ component = shallowMount(functionDetailsComponent, {
+ localVue,
+ store,
+ propsData: {
+ func: serviceStub,
+ hasPrometheus: false,
+ clustersPath: '/clusters',
+ helpPath: '/help',
+ },
+ });
+
+ expect(
+ component.vm.$el.querySelector('.serverless-function-description').querySelector('div')
+ .innerHTML.length,
+ ).toEqual(0);
+ });
+ });
+});
diff --git a/spec/javascripts/serverless/components/function_row_spec.js b/spec/javascripts/serverless/components/function_row_spec.js
index 6933a8f6c87e6..3987e1753bd0b 100644
--- a/spec/javascripts/serverless/components/function_row_spec.js
+++ b/spec/javascripts/serverless/components/function_row_spec.js
@@ -1,11 +1,9 @@
-import Vue from 'vue';
-
import functionRowComponent from '~/serverless/components/function_row.vue';
-import mountComponent from 'spec/helpers/vue_mount_component_helper';
+import { shallowMount } from '@vue/test-utils';
import { mockServerlessFunction } from '../mock_data';
-const createComponent = func => mountComponent(Vue.extend(functionRowComponent), { func });
+const createComponent = func => shallowMount(functionRowComponent, { propsData: { func } }).vm;
describe('functionRowComponent', () => {
it('Parses the function details correctly', () => {
@@ -13,10 +11,7 @@ describe('functionRowComponent', () => {
expect(vm.$el.querySelector('b').innerHTML).toEqual(mockServerlessFunction.name);
expect(vm.$el.querySelector('span').innerHTML).toEqual(mockServerlessFunction.image);
- expect(vm.$el.querySelector('time').getAttribute('data-original-title')).not.toBe(null);
- expect(vm.$el.querySelector('div.url-text-field').innerHTML).toEqual(
- mockServerlessFunction.url,
- );
+ expect(vm.$el.querySelector('timeago-stub').getAttribute('time')).not.toBe(null);
vm.$destroy();
});
@@ -25,8 +20,6 @@ describe('functionRowComponent', () => {
const vm = createComponent(mockServerlessFunction);
expect(vm.checkClass(vm.$el.querySelector('p'))).toBe(true); // check somewhere inside the row
- expect(vm.checkClass(vm.$el.querySelector('svg'))).toBe(false); // check a button image
- expect(vm.checkClass(vm.$el.querySelector('div.url-text-field'))).toBe(false); // check the url bar
vm.$destroy();
});
diff --git a/spec/javascripts/serverless/components/functions_spec.js b/spec/javascripts/serverless/components/functions_spec.js
index 85cfe71281ff8..c32978ea58a3b 100644
--- a/spec/javascripts/serverless/components/functions_spec.js
+++ b/spec/javascripts/serverless/components/functions_spec.js
@@ -1,68 +1,101 @@
-import Vue from 'vue';
+import Vuex from 'vuex';
import functionsComponent from '~/serverless/components/functions.vue';
-import mountComponent from 'spec/helpers/vue_mount_component_helper';
-import ServerlessStore from '~/serverless/stores/serverless_store';
-
+import { createLocalVue, shallowMount } from '@vue/test-utils';
+import { createStore } from '~/serverless/store';
import { mockServerlessFunctions } from '../mock_data';
-const createComponent = (
- functions,
- installed = true,
- loadingData = true,
- hasFunctionData = true,
-) => {
- const component = Vue.extend(functionsComponent);
+describe('functionsComponent', () => {
+ let component;
+ let store;
+ let localVue;
+
+ beforeEach(() => {
+ localVue = createLocalVue();
+ localVue.use(Vuex);
- return mountComponent(component, {
- functions,
- installed,
- clustersPath: '/testClusterPath',
- helpPath: '/helpPath',
- loadingData,
- hasFunctionData,
+ store = createStore();
});
-};
-describe('functionsComponent', () => {
- it('should render empty state when Knative is not installed', () => {
- const vm = createComponent({}, false);
+ afterEach(() => {
+ component.vm.$destroy();
+ });
- expect(vm.$el.querySelector('div.row').classList.contains('js-empty-state')).toBe(true);
- expect(vm.$el.querySelector('h4.state-title').innerHTML.trim()).toEqual(
- 'Getting started with serverless',
- );
+ it('should render empty state when Knative is not installed', () => {
+ component = shallowMount(functionsComponent, {
+ localVue,
+ store,
+ propsData: {
+ installed: false,
+ clustersPath: '',
+ helpPath: '',
+ statusPath: '',
+ },
+ sync: false,
+ });
- vm.$destroy();
+ expect(component.vm.$el.querySelector('emptystate-stub')).not.toBe(null);
});
it('should render a loading component', () => {
- const vm = createComponent({});
+ store.dispatch('requestFunctionsLoading');
+ component = shallowMount(functionsComponent, {
+ localVue,
+ store,
+ propsData: {
+ installed: true,
+ clustersPath: '',
+ helpPath: '',
+ statusPath: '',
+ },
+ sync: false,
+ });
- expect(vm.$el.querySelector('.gl-responsive-table-row')).not.toBe(null);
- expect(vm.$el.querySelector('div.animation-container')).not.toBe(null);
+ expect(component.vm.$el.querySelector('glloadingicon-stub')).not.toBe(null);
});
it('should render empty state when there is no function data', () => {
- const vm = createComponent({}, true, false, false);
+ store.dispatch('receiveFunctionsNoDataSuccess');
+ component = shallowMount(functionsComponent, {
+ localVue,
+ store,
+ propsData: {
+ installed: true,
+ clustersPath: '',
+ helpPath: '',
+ statusPath: '',
+ },
+ sync: false,
+ });
expect(
- vm.$el.querySelector('.empty-state, .js-empty-state').classList.contains('js-empty-state'),
+ component.vm.$el
+ .querySelector('.empty-state, .js-empty-state')
+ .classList.contains('js-empty-state'),
).toBe(true);
- expect(vm.$el.querySelector('h4.state-title').innerHTML.trim()).toEqual(
+ expect(component.vm.$el.querySelector('.state-title, .text-center').innerHTML.trim()).toEqual(
'No functions available',
);
-
- vm.$destroy();
});
it('should render the functions list', () => {
- const store = new ServerlessStore(false, '/cluster_path', 'help_path');
- store.updateFunctionsFromServer(mockServerlessFunctions);
- const vm = createComponent(store.state.functions, true, false);
+ component = shallowMount(functionsComponent, {
+ localVue,
+ store,
+ propsData: {
+ installed: true,
+ clustersPath: '',
+ helpPath: '',
+ statusPath: '',
+ },
+ sync: false,
+ });
+
+ component.vm.$store.dispatch('receiveFunctionsSuccess', mockServerlessFunctions);
- expect(vm.$el.querySelector('div.groups-list-tree-container')).not.toBe(null);
- expect(vm.$el.querySelector('#env-global').classList.contains('has-children')).toBe(true);
+ return component.vm.$nextTick().then(() => {
+ expect(component.vm.$el.querySelector('environmentrow-stub')).not.toBe(null);
+ });
});
});
diff --git a/spec/javascripts/serverless/components/missing_prometheus_spec.js b/spec/javascripts/serverless/components/missing_prometheus_spec.js
new file mode 100644
index 0000000000000..77aca03772bc9
--- /dev/null
+++ b/spec/javascripts/serverless/components/missing_prometheus_spec.js
@@ -0,0 +1,37 @@
+import missingPrometheusComponent from '~/serverless/components/missing_prometheus.vue';
+import { shallowMount } from '@vue/test-utils';
+
+const createComponent = missingData =>
+ shallowMount(missingPrometheusComponent, {
+ propsData: {
+ clustersPath: '/clusters',
+ helpPath: '/help',
+ missingData,
+ },
+ }).vm;
+
+describe('missingPrometheusComponent', () => {
+ let vm;
+
+ afterEach(() => {
+ vm.$destroy();
+ });
+
+ it('should render missing prometheus message', () => {
+ vm = createComponent(false);
+
+ expect(vm.$el.querySelector('.state-description').innerHTML.trim()).toContain(
+ 'Function invocation metrics require Prometheus to be installed first.',
+ );
+
+ expect(vm.$el.querySelector('glbutton-stub').getAttribute('variant')).toEqual('success');
+ });
+
+ it('should render no prometheus data message', () => {
+ vm = createComponent(true);
+
+ expect(vm.$el.querySelector('.state-description').innerHTML.trim()).toContain(
+ 'Invocation metrics loading or not available at this time.',
+ );
+ });
+});
diff --git a/spec/javascripts/serverless/components/pod_box_spec.js b/spec/javascripts/serverless/components/pod_box_spec.js
new file mode 100644
index 0000000000000..69ac1a2bb5f12
--- /dev/null
+++ b/spec/javascripts/serverless/components/pod_box_spec.js
@@ -0,0 +1,22 @@
+import podBoxComponent from '~/serverless/components/pod_box.vue';
+import { shallowMount } from '@vue/test-utils';
+
+const createComponent = count =>
+ shallowMount(podBoxComponent, {
+ propsData: {
+ count,
+ },
+ }).vm;
+
+describe('podBoxComponent', () => {
+ it('should render three boxes', () => {
+ const count = 3;
+ const vm = createComponent(count);
+ const rects = vm.$el.querySelectorAll('rect');
+
+ expect(rects.length).toEqual(3);
+ expect(parseInt(rects[2].getAttribute('x'), 10)).toEqual(40);
+
+ vm.$destroy();
+ });
+});
diff --git a/spec/javascripts/serverless/components/url_spec.js b/spec/javascripts/serverless/components/url_spec.js
index 21a879a49bb92..08c3e4146b1c6 100644
--- a/spec/javascripts/serverless/components/url_spec.js
+++ b/spec/javascripts/serverless/components/url_spec.js
@@ -1,15 +1,13 @@
import Vue from 'vue';
-
import urlComponent from '~/serverless/components/url.vue';
-import mountComponent from 'spec/helpers/vue_mount_component_helper';
-
-const createComponent = uri => {
- const component = Vue.extend(urlComponent);
+import { shallowMount } from '@vue/test-utils';
- return mountComponent(component, {
- uri,
- });
-};
+const createComponent = uri =>
+ shallowMount(Vue.extend(urlComponent), {
+ propsData: {
+ uri,
+ },
+ }).vm;
describe('urlComponent', () => {
it('should render correctly', () => {
@@ -17,9 +15,7 @@ describe('urlComponent', () => {
const vm = createComponent(uri);
expect(vm.$el.classList.contains('clipboard-group')).toBe(true);
- expect(vm.$el.querySelector('.js-clipboard-btn').getAttribute('data-clipboard-text')).toEqual(
- uri,
- );
+ expect(vm.$el.querySelector('clipboardbutton-stub').getAttribute('text')).toEqual(uri);
expect(vm.$el.querySelector('.url-text-field').innerHTML).toEqual(uri);
diff --git a/spec/javascripts/serverless/mock_data.js b/spec/javascripts/serverless/mock_data.js
index ecd393b174ce1..a2c1861632435 100644
--- a/spec/javascripts/serverless/mock_data.js
+++ b/spec/javascripts/serverless/mock_data.js
@@ -77,3 +77,60 @@ export const mockMultilineServerlessFunction = {
description: 'testfunc1\nA test service line\\nWith additional services',
image: 'knative-test-container-buildtemplate',
};
+
+export const mockMetrics = {
+ success: true,
+ last_update: '2019-02-28T19:11:38.926Z',
+ metrics: {
+ id: 22,
+ title: 'Knative function invocations',
+ required_metrics: ['container_memory_usage_bytes', 'container_cpu_usage_seconds_total'],
+ weight: 0,
+ y_label: 'Invocations',
+ queries: [
+ {
+ query_range:
+ 'floor(sum(rate(istio_revision_request_count{destination_configuration="%{function_name}", destination_namespace="%{kube_namespace}"}[1m])*30))',
+ unit: 'requests',
+ label: 'invocations / minute',
+ result: [
+ {
+ metric: {},
+ values: [[1551352298.756, '0'], [1551352358.756, '0']],
+ },
+ ],
+ },
+ ],
+ },
+};
+
+export const mockNormalizedMetrics = {
+ id: 22,
+ title: 'Knative function invocations',
+ required_metrics: ['container_memory_usage_bytes', 'container_cpu_usage_seconds_total'],
+ weight: 0,
+ y_label: 'Invocations',
+ queries: [
+ {
+ query_range:
+ 'floor(sum(rate(istio_revision_request_count{destination_configuration="%{function_name}", destination_namespace="%{kube_namespace}"}[1m])*30))',
+ unit: 'requests',
+ label: 'invocations / minute',
+ result: [
+ {
+ metric: {},
+ values: [
+ {
+ time: '2019-02-28T11:11:38.756Z',
+ value: 0,
+ },
+ {
+ time: '2019-02-28T11:12:38.756Z',
+ value: 0,
+ },
+ ],
+ },
+ ],
+ },
+ ],
+};
diff --git a/spec/javascripts/serverless/store/actions_spec.js b/spec/javascripts/serverless/store/actions_spec.js
new file mode 100644
index 0000000000000..602798573e9fb
--- /dev/null
+++ b/spec/javascripts/serverless/store/actions_spec.js
@@ -0,0 +1,88 @@
+import MockAdapter from 'axios-mock-adapter';
+import statusCodes from '~/lib/utils/http_status';
+import { fetchFunctions, fetchMetrics } from '~/serverless/store/actions';
+import { mockServerlessFunctions, mockMetrics } from '../mock_data';
+import axios from '~/lib/utils/axios_utils';
+import testAction from '../../helpers/vuex_action_helper';
+import { adjustMetricQuery } from '../utils';
+
+describe('ServerlessActions', () => {
+ describe('fetchFunctions', () => {
+ it('should successfully fetch functions', done => {
+ const endpoint = '/functions';
+ const mock = new MockAdapter(axios);
+ mock.onGet(endpoint).reply(statusCodes.OK, JSON.stringify(mockServerlessFunctions));
+
+ testAction(
+ fetchFunctions,
+ { functionsPath: endpoint },
+ {},
+ [],
+ [
+ { type: 'requestFunctionsLoading' },
+ { type: 'receiveFunctionsSuccess', payload: mockServerlessFunctions },
+ ],
+ () => {
+ mock.restore();
+ done();
+ },
+ );
+ });
+
+ it('should successfully retry', done => {
+ const endpoint = '/functions';
+ const mock = new MockAdapter(axios);
+ mock.onGet(endpoint).reply(statusCodes.NO_CONTENT);
+
+ testAction(
+ fetchFunctions,
+ { functionsPath: endpoint },
+ {},
+ [],
+ [{ type: 'requestFunctionsLoading' }],
+ () => {
+ mock.restore();
+ done();
+ },
+ );
+ });
+ });
+
+ describe('fetchMetrics', () => {
+ it('should return no prometheus', done => {
+ const endpoint = '/metrics';
+ const mock = new MockAdapter(axios);
+ mock.onGet(endpoint).reply(statusCodes.NO_CONTENT);
+
+ testAction(
+ fetchMetrics,
+ { metricsPath: endpoint, hasPrometheus: false },
+ {},
+ [],
+ [{ type: 'receiveMetricsNoPrometheus' }],
+ () => {
+ mock.restore();
+ done();
+ },
+ );
+ });
+
+ it('should successfully fetch metrics', done => {
+ const endpoint = '/metrics';
+ const mock = new MockAdapter(axios);
+ mock.onGet(endpoint).reply(statusCodes.OK, JSON.stringify(mockMetrics));
+
+ testAction(
+ fetchMetrics,
+ { metricsPath: endpoint, hasPrometheus: true },
+ {},
+ [],
+ [{ type: 'receiveMetricsSuccess', payload: adjustMetricQuery(mockMetrics) }],
+ () => {
+ mock.restore();
+ done();
+ },
+ );
+ });
+ });
+});
diff --git a/spec/javascripts/serverless/store/getters_spec.js b/spec/javascripts/serverless/store/getters_spec.js
new file mode 100644
index 0000000000000..fb549c8f153fc
--- /dev/null
+++ b/spec/javascripts/serverless/store/getters_spec.js
@@ -0,0 +1,43 @@
+import serverlessState from '~/serverless/store/state';
+import * as getters from '~/serverless/store/getters';
+import { mockServerlessFunctions } from '../mock_data';
+
+describe('Serverless Store Getters', () => {
+ let state;
+
+ beforeEach(() => {
+ state = serverlessState;
+ });
+
+ describe('hasPrometheusMissingData', () => {
+ it('should return false if Prometheus is not installed', () => {
+ state.hasPrometheus = false;
+
+ expect(getters.hasPrometheusMissingData(state)).toEqual(false);
+ });
+
+ it('should return false if Prometheus is installed and there is data', () => {
+ state.hasPrometheusData = true;
+
+ expect(getters.hasPrometheusMissingData(state)).toEqual(false);
+ });
+
+ it('should return true if Prometheus is installed and there is no data', () => {
+ state.hasPrometheus = true;
+ state.hasPrometheusData = false;
+
+ expect(getters.hasPrometheusMissingData(state)).toEqual(true);
+ });
+ });
+
+ describe('getFunctions', () => {
+ it('should translate the raw function array to group the functions per environment scope', () => {
+ state.functions = mockServerlessFunctions;
+
+ const funcs = getters.getFunctions(state);
+
+ expect(Object.keys(funcs)).toContain('*');
+ expect(funcs['*'].length).toEqual(2);
+ });
+ });
+});
diff --git a/spec/javascripts/serverless/store/mutations_spec.js b/spec/javascripts/serverless/store/mutations_spec.js
new file mode 100644
index 0000000000000..ca3053e5c384f
--- /dev/null
+++ b/spec/javascripts/serverless/store/mutations_spec.js
@@ -0,0 +1,86 @@
+import mutations from '~/serverless/store/mutations';
+import * as types from '~/serverless/store/mutation_types';
+import { mockServerlessFunctions, mockMetrics } from '../mock_data';
+
+describe('ServerlessMutations', () => {
+ describe('Functions List Mutations', () => {
+ it('should ensure loading is true', () => {
+ const state = {};
+
+ mutations[types.REQUEST_FUNCTIONS_LOADING](state);
+
+ expect(state.isLoading).toEqual(true);
+ });
+
+ it('should set proper state once functions are loaded', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_FUNCTIONS_SUCCESS](state, mockServerlessFunctions);
+
+ expect(state.isLoading).toEqual(false);
+ expect(state.hasFunctionData).toEqual(true);
+ expect(state.functions).toEqual(mockServerlessFunctions);
+ });
+
+ it('should ensure loading has stopped and hasFunctionData is false when there are no functions available', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_FUNCTIONS_NODATA_SUCCESS](state);
+
+ expect(state.isLoading).toEqual(false);
+ expect(state.hasFunctionData).toEqual(false);
+ expect(state.functions).toBe(undefined);
+ });
+
+ it('should ensure loading has stopped, and an error is raised', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_FUNCTIONS_ERROR](state, 'sample error');
+
+ expect(state.isLoading).toEqual(false);
+ expect(state.hasFunctionData).toEqual(false);
+ expect(state.functions).toBe(undefined);
+ expect(state.error).not.toBe(undefined);
+ });
+ });
+
+ describe('Function Details Metrics Mutations', () => {
+ it('should ensure isLoading and hasPrometheus data flags indicate data is loaded', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_METRICS_SUCCESS](state, mockMetrics);
+
+ expect(state.isLoading).toEqual(false);
+ expect(state.hasPrometheusData).toEqual(true);
+ expect(state.graphData).toEqual(mockMetrics);
+ });
+
+ it('should ensure isLoading and hasPrometheus data flags are cleared indicating no functions available', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_METRICS_NODATA_SUCCESS](state);
+
+ expect(state.isLoading).toEqual(false);
+ expect(state.hasPrometheusData).toEqual(false);
+ expect(state.graphData).toBe(undefined);
+ });
+
+ it('should properly indicate an error', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_METRICS_ERROR](state, 'sample error');
+
+ expect(state.hasPrometheusData).toEqual(false);
+ expect(state.error).not.toBe(undefined);
+ });
+
+ it('should properly indicate when prometheus is installed', () => {
+ const state = {};
+
+ mutations[types.RECEIVE_METRICS_NO_PROMETHEUS](state);
+
+ expect(state.hasPrometheus).toEqual(false);
+ expect(state.hasPrometheusData).toEqual(false);
+ });
+ });
+});
diff --git a/spec/javascripts/serverless/stores/serverless_store_spec.js b/spec/javascripts/serverless/stores/serverless_store_spec.js
deleted file mode 100644
index 72fd903d7d189..0000000000000
--- a/spec/javascripts/serverless/stores/serverless_store_spec.js
+++ /dev/null
@@ -1,36 +0,0 @@
-import ServerlessStore from '~/serverless/stores/serverless_store';
-import { mockServerlessFunctions, mockServerlessFunctionsDiffEnv } from '../mock_data';
-
-describe('Serverless Functions Store', () => {
- let store;
-
- beforeEach(() => {
- store = new ServerlessStore(false, '/cluster_path', 'help_path');
- });
-
- describe('#updateFunctionsFromServer', () => {
- it('should pass an empty hash object', () => {
- store.updateFunctionsFromServer();
-
- expect(store.state.functions).toEqual({});
- });
-
- it('should group functions to one global environment', () => {
- const mockServerlessData = mockServerlessFunctions;
- store.updateFunctionsFromServer(mockServerlessData);
-
- expect(Object.keys(store.state.functions)).toEqual(jasmine.objectContaining(['*']));
- expect(store.state.functions['*'].length).toEqual(2);
- });
-
- it('should group functions to multiple environments', () => {
- const mockServerlessData = mockServerlessFunctionsDiffEnv;
- store.updateFunctionsFromServer(mockServerlessData);
-
- expect(Object.keys(store.state.functions)).toEqual(jasmine.objectContaining(['*']));
- expect(store.state.functions['*'].length).toEqual(1);
- expect(store.state.functions.test.length).toEqual(1);
- expect(store.state.functions.test[0].name).toEqual('testfunc2');
- });
- });
-});
diff --git a/spec/javascripts/serverless/utils.js b/spec/javascripts/serverless/utils.js
new file mode 100644
index 0000000000000..5ce2e37d49367
--- /dev/null
+++ b/spec/javascripts/serverless/utils.js
@@ -0,0 +1,20 @@
+export const adjustMetricQuery = data => {
+ const updatedMetric = data.metrics;
+
+ const queries = data.metrics.queries.map(query => ({
+ ...query,
+ result: query.result.map(result => ({
+ ...result,
+ values: result.values.map(([timestamp, value]) => ({
+ time: new Date(timestamp * 1000).toISOString(),
+ value: Number(value),
+ })),
+ })),
+ }));
+
+ updatedMetric.queries = queries;
+ return updatedMetric;
+};
+
+// prevent babel-plugin-rewire from generating an invalid default during karma tests
+export default () => {};
diff --git a/spec/lib/gitlab/prometheus/queries/knative_invocation_query_spec.rb b/spec/lib/gitlab/prometheus/queries/knative_invocation_query_spec.rb
new file mode 100644
index 0000000000000..7f6283715f227
--- /dev/null
+++ b/spec/lib/gitlab/prometheus/queries/knative_invocation_query_spec.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Prometheus::Queries::KnativeInvocationQuery do
+ include PrometheusHelpers
+
+ let(:project) { create(:project) }
+ let(:serverless_func) { Serverless::Function.new(project, 'test-name', 'test-ns') }
+
+ let(:client) { double('prometheus_client') }
+ subject { described_class.new(client) }
+
+ context 'verify queries' do
+ before do
+ allow(PrometheusMetric).to receive(:find_by_identifier).and_return(create(:prometheus_metric, query: prometheus_istio_query('test-name', 'test-ns')))
+ allow(client).to receive(:query_range)
+ end
+
+ it 'has the query, but no data' do
+ results = subject.query(serverless_func.id)
+
+ expect(results.queries[0][:query_range]).to eql('floor(sum(rate(istio_revision_request_count{destination_configuration="test-name", destination_namespace="test-ns"}[1m])*30))')
+ end
+ end
+end
diff --git a/spec/models/serverless/function_spec.rb b/spec/models/serverless/function_spec.rb
new file mode 100644
index 0000000000000..1854d5f94151c
--- /dev/null
+++ b/spec/models/serverless/function_spec.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Serverless::Function do
+ let(:project) { create(:project) }
+ let(:func) { described_class.new(project, 'test', 'test-ns') }
+
+ it 'has a proper id' do
+ expect(func.id).to eql("#{project.id}/test/test-ns")
+ expect(func.name).to eql("test")
+ expect(func.namespace).to eql("test-ns")
+ end
+
+ it 'can decode an identifier' do
+ f = described_class.find_by_id("#{project.id}/testfunc/dummy-ns")
+
+ expect(f.name).to eql("testfunc")
+ expect(f.namespace).to eql("dummy-ns")
+ end
+end
diff --git a/spec/support/helpers/prometheus_helpers.rb b/spec/support/helpers/prometheus_helpers.rb
index 08d1d7a605915..87f825152cf78 100644
--- a/spec/support/helpers/prometheus_helpers.rb
+++ b/spec/support/helpers/prometheus_helpers.rb
@@ -7,6 +7,10 @@ def prometheus_cpu_query(environment_slug)
%{avg(rate(container_cpu_usage_seconds_total{container_name!="POD",environment="#{environment_slug}"}[2m])) * 100}
end
+ def prometheus_istio_query(function_name, kube_namespace)
+ %{floor(sum(rate(istio_revision_request_count{destination_configuration=\"#{function_name}\", destination_namespace=\"#{kube_namespace}\"}[1m])*30))}
+ end
+
def prometheus_ping_url(prometheus_query)
query = { query: prometheus_query }.to_query
--
GitLab