-
Notifications
You must be signed in to change notification settings - Fork 2.5k
/
plugin-metrics-creator.ts
189 lines (167 loc) · 7.84 KB
/
plugin-metrics-creator.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
// *****************************************************************************
// Copyright (C) 2019 Red Hat, Inc. and others.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// http://www.eclipse.org/legal/epl-2.0.
//
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License v. 2.0 are satisfied: GNU General Public License, version 2
// with the GNU Classpath Exception which is available at
// https://www.gnu.org/software/classpath/license.html.
//
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
// *****************************************************************************
import { inject, injectable } from '@theia/core/shared/inversify';
import { PluginMetrics, METRICS_TIMEOUT } from '../common/metrics-protocol';
import { AnalyticsFromRequests, DataFromRequest, createRequestData, createDefaultAnalytics, MetricsMap } from '../common/plugin-metrics-types';
@injectable()
export class PluginMetricsCreator {
@inject(PluginMetrics)
private pluginMetrics: PluginMetrics;
private _extensionIDAnalytics: MetricsMap;
private NODE_BASED_REGEX = /Request(.*?)failed/;
constructor() {
this.setPluginMetrics();
this._extensionIDAnalytics = {};
}
/**
* Create an error metric for requestData.pluginID by attempting to extract the erroring
* language server method from the requestData.errorContentsOrMethod. If it cannot extract the
* error language server method from requestData.errorContentsOrMethod then it will not
* create a metric.
*
* @param pluginID The id of the plugin
* @param errorContents The contents that the language server error has produced
*/
async createErrorMetric(requestData: DataFromRequest): Promise<void> {
if (!requestData.pluginID) {
return;
}
const method = this.extractMethodFromValue(requestData.errorContentsOrMethod);
// only log the metric if we can find the method that it occurred in
if (method) {
const createdMetric = createRequestData(requestData.pluginID, method, requestData.timeTaken);
this.createMetric(createdMetric, false);
this.decreaseExtensionRequests(requestData.pluginID, method);
}
}
/**
* Decreases the total requests and the successful responses for pluginID with method by 1.
*
* This is needed because an error and a successful language server request aren't currently
* associated together because of https://github.com/microsoft/vscode-languageserver-node/issues/517.
* That means that every language server request that resolves counts as a successful language server request.
* Therefore, we need to decrease the extension requests for pluginID when we know there is an error.
* Otherwise, for every language server request that errors we would count it as both a success and a failure.
*
* @param pluginID The id of the plugin that should have the decreased requests
*/
private decreaseExtensionRequests(pluginID: string, method: string): void {
const thisExtension = this._extensionIDAnalytics[pluginID];
if (thisExtension) {
const currentAnalytics = thisExtension[method];
if (currentAnalytics) {
currentAnalytics.totalRequests -= 1;
currentAnalytics.successfulResponses -= 1;
}
}
}
/**
* Update the internal metrics structure for pluginID with method when a request is made
*
* @param requestData The data from the request that was made
* @param isRequestSuccessful If the language server request was successful or not
*/
async createMetric(requestData: DataFromRequest, isRequestSuccessful: boolean): Promise<void> {
if (!requestData.pluginID) {
return;
}
// When we are in this function we know its a method so we can make it clearer
const method = requestData.errorContentsOrMethod;
const defaultAnalytic = createDefaultAnalytics(requestData.timeTaken, isRequestSuccessful);
this.createExtensionIDAnalyticIfNotFound(requestData, defaultAnalytic);
this.createExtensionIDMethodIfNotFound(requestData, defaultAnalytic);
const thisExtension = this._extensionIDAnalytics[requestData.pluginID];
if (thisExtension) {
const currentAnalytic = thisExtension[method];
if (currentAnalytic) {
currentAnalytic.totalRequests += 1;
if (isRequestSuccessful) {
currentAnalytic.successfulResponses += 1;
}
if (isRequestSuccessful) {
currentAnalytic.sumOfTimeForSuccess = currentAnalytic.sumOfTimeForSuccess + requestData.timeTaken;
} else {
currentAnalytic.sumOfTimeForFailure = currentAnalytic.sumOfTimeForFailure + requestData.timeTaken;
}
}
}
}
/**
* Create an entry in _extensionIDAnalytics with createdAnalytic if there does not exist one
*
* @param requestData data that we will turn into metrics
* @param createdAnalytic the analytic being created
*/
private createExtensionIDAnalyticIfNotFound(requestData: DataFromRequest, createdAnalytic: AnalyticsFromRequests): void {
const method = requestData.errorContentsOrMethod; // We know its a metric if this is being called
if (!this._extensionIDAnalytics[requestData.pluginID]) {
this._extensionIDAnalytics[requestData.pluginID] = {
[method]: createdAnalytic
};
}
}
/**
* Create an entry in _extensionIDAnalytics for requestData.pluginID with requestData.errorContentsOrMethod as the method
* if there does not exist one
*
* @param requestData data that we will turn into metrics
* @param createdAnalytic the analytic being created
*/
private createExtensionIDMethodIfNotFound(requestData: DataFromRequest, createdAnalytic: AnalyticsFromRequests): void {
const method = requestData.errorContentsOrMethod; // We know its a metric if this is being called
if (this._extensionIDAnalytics[requestData.pluginID]) {
const methodToAnalyticMap = this._extensionIDAnalytics[requestData.pluginID];
if (!methodToAnalyticMap[method]) {
methodToAnalyticMap[method] = createdAnalytic;
}
}
}
/**
* setPluginMetrics is a constant running function that sets
* pluginMetrics every {$METRICS_TIMEOUT} seconds so that it doesn't
* update /metrics on every request
*/
private setPluginMetrics(): void {
const self = this;
setInterval(() => {
if (Object.keys(self._extensionIDAnalytics).length !== 0) {
self.pluginMetrics.setMetrics(JSON.stringify(self._extensionIDAnalytics));
}
}, METRICS_TIMEOUT);
}
// Map of plugin extension id to method to analytic
get extensionIDAnalytics(): MetricsMap {
return this._extensionIDAnalytics;
}
/**
* Attempts to extract the method name from the current errorContents using the
* vscode-languageclient matching regex.
*
* If it cannot find a match in the errorContents it returns undefined
*
* @param errorContents The contents of the current error or undefined
*/
private extractMethodFromValue(errorContents: string | undefined): string | undefined {
if (!errorContents) {
return undefined;
}
const matches = errorContents.match(this.NODE_BASED_REGEX);
if (matches) {
return matches[1].trim();
}
return undefined;
}
}