| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| |
| import { Commit, Dispatch, MutationTree } from 'vuex'; |
| import { AxiosResponse } from 'axios'; |
| |
| import graph from '@/graph'; |
| import * as types from '../../mutation-types'; |
| import { |
| IOption, |
| ITaskOptions, |
| TaskSourceType, |
| TaskListSourceType, |
| TracesSourceType, |
| IHeaderSource, |
| } from '@/types/profile'; |
| import { InitTaskField, InitTaskFieldSource, ChangeTaskOpt } from './profile-constant'; |
| |
| export interface State { |
| headerSource: IHeaderSource; |
| newTaskFields: ITaskOptions; |
| taskFieldSource: TaskSourceType; |
| taskListSource: TaskListSourceType[]; |
| segmentSpans: any[]; |
| currentSegment: any; |
| segmentList: TracesSourceType[]; |
| profileAnalyzation: any; |
| highlightTop: boolean; |
| currentSpan: any; |
| profileErrors: { [key: string]: string }; |
| } |
| const initState: State = { |
| headerSource: { |
| serviceSource: [{ key: '', label: 'None' }], |
| currentService: { key: '', label: 'None' }, |
| endpointName: '', |
| }, |
| newTaskFields: InitTaskField, |
| taskFieldSource: InitTaskFieldSource, |
| taskListSource: [], |
| segmentSpans: [], |
| currentSegment: { |
| operationNames: [], |
| duration: 0, |
| isError: false, |
| key: '', |
| start: '', |
| traceIds: [], |
| }, |
| segmentList: [], |
| profileAnalyzation: [], |
| highlightTop: true, |
| currentSpan: {}, |
| profileErrors: {}, |
| }; |
| // getters |
| const getters = { |
| updateTaskOpt() { |
| return ChangeTaskOpt; |
| }, |
| }; |
| |
| // mutations |
| const mutations: MutationTree<State> = { |
| [types.SET_SERVICES](state: State, data: any[]) { |
| state.headerSource.serviceSource = [{ key: 'all', label: 'All' }, ...data]; |
| state.headerSource.currentService = state.headerSource.serviceSource[0]; |
| state.taskFieldSource.serviceSource = data; |
| state.newTaskFields.service = data[0] || {}; |
| }, |
| [types.SET_TASK_OPTIONS](state: State, data: { type: string; item: IOption }) { |
| const param = ['minThreshold', 'endpointName']; |
| state.newTaskFields = { |
| ...state.newTaskFields, |
| [data.type]: param.includes(data.type) ? data.item.key : data.item, |
| }; |
| }, |
| [types.SET_TASK_LIST](state: State, data: TaskListSourceType[]) { |
| state.taskListSource = data; |
| }, |
| [types.SET_SEGMENT_SPANS](state: State, data: any[]) { |
| state.segmentSpans = data; |
| }, |
| [types.SET_CURRENT_SPAN](state: State, data: any) { |
| state.currentSpan = data; |
| }, |
| [types.SET_SEGMENT_LIST](state: State, data: TracesSourceType[]) { |
| state.segmentList = data; |
| }, |
| [types.SET_CURRENT_SEGMENT](state: State, data: any) { |
| state.currentSegment = data; |
| }, |
| [types.SET_PROFILE_ANALYZATION](state: State, data: any[]) { |
| state.profileAnalyzation = data; |
| }, |
| [types.SET_HEADER_SOURCE](state: State, data: IHeaderSource) { |
| state.headerSource = { |
| ...state.headerSource, |
| ...data, |
| }; |
| }, |
| [types.SET_HIGHLIGHT_TOP](state: State) { |
| state.highlightTop = !state.highlightTop; |
| }, |
| [types.SET_PROFILE_ERRORS](state: State, data: { msg: string; desc: string }) { |
| state.profileErrors = { |
| ...state.profileErrors, |
| [data.msg]: data.desc, |
| }; |
| }, |
| }; |
| |
| // actions |
| const actions = { |
| GET_SERVICES(context: { commit: Commit; dispatch: Dispatch }, params: { duration: any; keyword: string }) { |
| if (!params.keyword) { |
| params.keyword = ''; |
| } |
| graph |
| .query('queryServices') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'serviceProfileErrors', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return context.commit(types.SET_SERVICES, []); |
| } |
| context.commit(types.SET_SERVICES, res.data.data.services); |
| context.dispatch('GET_TASK_LIST'); |
| }); |
| }, |
| GET_TASK_LIST(context: { state: State; dispatch: Dispatch; commit: Commit }) { |
| const { headerSource } = context.state; |
| const param = { |
| serviceId: headerSource.currentService.key === 'all' ? '' : headerSource.currentService.key, |
| endpointName: headerSource.endpointName, |
| }; |
| |
| graph |
| .query('getProfileTaskList') |
| .params(param) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'getProfileTaskList', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return context.commit(types.SET_TASK_LIST, []); |
| } |
| context.commit(types.SET_TASK_LIST, res.data.data.getProfileTaskList); |
| const list = res.data.data.getProfileTaskList; |
| if (!list.length) { |
| return; |
| } |
| context.dispatch('GET_SEGMENT_LIST', { taskID: list[0].id }); |
| return; |
| }); |
| }, |
| GET_SEGMENT_LIST(context: { commit: Commit; dispatch: Dispatch }, params: { taskID: string }) { |
| graph |
| .query('getProfileTaskSegmentList') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'getProfileTaskSegmentList', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return context.commit(types.SET_SEGMENT_LIST, []); |
| } |
| const { getProfileTaskSegmentList } = res.data.data; |
| |
| context.commit(types.SET_SEGMENT_LIST, getProfileTaskSegmentList); |
| if (getProfileTaskSegmentList[0]) { |
| context.commit(types.SET_CURRENT_SEGMENT, getProfileTaskSegmentList[0]); |
| context.dispatch('GET_SEGMENT_SPANS', { segmentId: getProfileTaskSegmentList[0].segmentId }); |
| } else { |
| context.commit(types.SET_CURRENT_SEGMENT, { |
| traceIds: [], |
| }); |
| context.commit(types.SET_SEGMENT_SPANS, []); |
| context.commit(types.SET_PROFILE_ANALYZATION, []); |
| } |
| }); |
| }, |
| GET_SEGMENT_SPANS(context: { state: State; commit: Commit; dispatch: Dispatch }, params: { segmentId: string }) { |
| graph |
| .query('queryProfileSegment') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'queryProfileSegment', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return context.commit(types.SET_SEGMENT_SPANS, []); |
| } |
| const { getProfiledSegment } = res.data.data; |
| if (!getProfiledSegment) { |
| return; |
| } |
| context.commit(types.SET_SEGMENT_SPANS, getProfiledSegment.spans); |
| if (!(getProfiledSegment.spans && getProfiledSegment.spans.length)) { |
| return; |
| } |
| const index = getProfiledSegment.spans.length - 1 || 0; |
| context.commit(types.SET_CURRENT_SPAN, getProfiledSegment.spans[index]); |
| }) |
| .catch((error: any) => { |
| throw error; |
| }); |
| }, |
| GET_PROFILE_ANALYZE( |
| context: { commit: Commit; state: State; dispatch: Dispatch }, |
| params: { segmentId: string; timeRanges: Array<{ start: number; end: number }> }, |
| ) { |
| return graph |
| .query('getProfileAnalyze') |
| .params(params) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'getProfileAnalyze', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return context.commit(types.SET_PROFILE_ANALYZATION, []); |
| } |
| const { getProfileAnalyze, tip } = res.data.data; |
| if (tip) { |
| return { tip }; |
| } |
| if (!getProfileAnalyze) { |
| context.commit(types.SET_PROFILE_ANALYZATION, []); |
| return; |
| } |
| context.commit(types.SET_PROFILE_ANALYZATION, getProfileAnalyze.trees); |
| }); |
| }, |
| CREATE_PROFILE_TASK(context: { commit: Commit; state: State; dispatch: Dispatch }, param: { startTime: number }) { |
| const { |
| service, |
| endpointName, |
| minThreshold, |
| monitorDuration, |
| dumpPeriod, |
| maxSamplingCount, |
| monitorTime, |
| } = context.state.newTaskFields; |
| const creationRequest = { |
| serviceId: service.key, |
| endpointName, |
| startTime: monitorTime.key === '1' ? param.startTime : new Date().getTime(), |
| duration: monitorDuration.key, |
| minDurationThreshold: Number(minThreshold), |
| dumpPeriod: dumpPeriod.key, |
| maxSamplingCount: maxSamplingCount.key, |
| }; |
| |
| return graph |
| .query('saveProfileTask') |
| .params({ creationRequest }) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'saveProfileTask', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return; |
| } |
| if (res.data.data && res.data.data.createTask && res.data.data.createTask.errorReason) { |
| return res.data.data.createTask; |
| } |
| context.dispatch('GET_TASK_LIST'); |
| return res.data.data.createTask; |
| }); |
| }, |
| GET_TASK_LOGS(context: { commit: Commit; state: State; dispatch: Dispatch }, param: { taskID: string }) { |
| return graph |
| .query('getProfileTaskLogs') |
| .params(param) |
| .then((res: AxiosResponse) => { |
| context.commit(types.SET_PROFILE_ERRORS, { msg: 'getProfileTaskLogs', desc: res.data.errors || '' }); |
| if (res.data.errors) { |
| return; |
| } |
| return res.data.data.getProfileTaskLogs; |
| }); |
| }, |
| }; |
| |
| export default { |
| namespaced: true, |
| state: initState, |
| getters, |
| actions, |
| mutations, |
| }; |