|
1 | | -import { Session as SessionInterface, SessionContext, SessionStatus } from '@sentry/types'; |
2 | | -import { dropUndefinedKeys, uuid4 } from '@sentry/utils'; |
| 1 | +import { |
| 2 | + AggregationCounts, |
| 3 | + RequestSessionStatus, |
| 4 | + Session as SessionInterface, |
| 5 | + SessionAggregates, |
| 6 | + SessionContext, |
| 7 | + SessionFlusher as SessionFlusherInterface, |
| 8 | + SessionStatus, |
| 9 | + Transport, |
| 10 | +} from '@sentry/types'; |
| 11 | +import { dropUndefinedKeys, logger, uuid4 } from '@sentry/utils'; |
| 12 | + |
| 13 | +import { getCurrentHub } from './hub'; |
3 | 14 |
|
4 | 15 | /** |
5 | 16 | * @inheritdoc |
@@ -123,3 +134,120 @@ export class Session implements SessionInterface { |
123 | 134 | }); |
124 | 135 | } |
125 | 136 | } |
| 137 | + |
| 138 | +type releaseHealthAttributes = { |
| 139 | + environment?: string; |
| 140 | + release: string; |
| 141 | +}; |
| 142 | + |
| 143 | +/** |
| 144 | + * @inheritdoc |
| 145 | + */ |
| 146 | +export class SessionFlusher implements SessionFlusherInterface { |
| 147 | + public readonly flushTimeout: number = 60; |
| 148 | + private _pendingAggregates: { [key: number]: AggregationCounts } = {}; |
| 149 | + private _sessionAttrs: releaseHealthAttributes; |
| 150 | + private _intervalId: ReturnType<typeof setInterval>; |
| 151 | + private _isEnabled: boolean = true; |
| 152 | + private _transport: Transport; |
| 153 | + |
| 154 | + constructor(transport: Transport, attrs: releaseHealthAttributes) { |
| 155 | + this._transport = transport; |
| 156 | + // Call to setInterval, so that flush is called every 60 seconds |
| 157 | + this._intervalId = setInterval(() => this.flush(), this.flushTimeout * 1000); |
| 158 | + this._sessionAttrs = attrs; |
| 159 | + } |
| 160 | + |
| 161 | + /** Sends session aggregates to Transport */ |
| 162 | + public sendSessionAggregates(sessionAggregates: SessionAggregates): void { |
| 163 | + if (!this._transport.sendSessionAggregates) { |
| 164 | + logger.warn("Dropping session because custom transport doesn't implement sendSessionAggregates"); |
| 165 | + return; |
| 166 | + } |
| 167 | + this._transport.sendSessionAggregates(sessionAggregates).then(null, reason => { |
| 168 | + logger.error(`Error while sending session: ${reason}`); |
| 169 | + }); |
| 170 | + } |
| 171 | + |
| 172 | + /** Checks if `pendingAggregates` has entries, and if it does flushes them by calling `sendSessions` */ |
| 173 | + flush(): void { |
| 174 | + const sessionAggregates = this.getSessionAggregates(); |
| 175 | + if (sessionAggregates.aggregates.length === 0) { |
| 176 | + return; |
| 177 | + } |
| 178 | + this._pendingAggregates = {}; |
| 179 | + this.sendSessionAggregates(sessionAggregates); |
| 180 | + } |
| 181 | + |
| 182 | + /** Massages the entries in `pendingAggregates` and returns aggregated sessions */ |
| 183 | + getSessionAggregates(): SessionAggregates { |
| 184 | + const aggregates: AggregationCounts[] = Object.keys(this._pendingAggregates).map((key: string) => { |
| 185 | + return this._pendingAggregates[parseInt(key)]; |
| 186 | + }); |
| 187 | + |
| 188 | + const sessionAggregates: SessionAggregates = { |
| 189 | + attrs: this._sessionAttrs, |
| 190 | + aggregates: aggregates, |
| 191 | + }; |
| 192 | + return dropUndefinedKeys(sessionAggregates); |
| 193 | + } |
| 194 | + |
| 195 | + /** JSDoc */ |
| 196 | + close(): void { |
| 197 | + clearInterval(this._intervalId); |
| 198 | + this._isEnabled = false; |
| 199 | + this.flush(); |
| 200 | + } |
| 201 | + |
| 202 | + /** |
| 203 | + * Wrapper function for _incrementSessionStatusCount that checks if the instance of SessionFlusher is enabled then |
| 204 | + * fetches the session status of the request from `_requestSession.status` on the scope and passes them to |
| 205 | + * `_incrementSessionStatusCount` along with the start date |
| 206 | + */ |
| 207 | + public incrementSessionStatusCount(): void { |
| 208 | + if (!this._isEnabled) { |
| 209 | + return; |
| 210 | + } |
| 211 | + const scope = getCurrentHub().getScope(); |
| 212 | + /* eslint-disable @typescript-eslint/no-unsafe-member-access */ |
| 213 | + const requestSession = (scope as any)._requestSession; |
| 214 | + |
| 215 | + if (requestSession && requestSession.status) { |
| 216 | + this._incrementSessionStatusCount(requestSession.status, new Date()); |
| 217 | + // This is not entirely necessarily but is added as a safe guard to indicate the bounds of a request and so in |
| 218 | + // case captureRequestSession is called more than once to prevent double count |
| 219 | + (scope as any)._requestSession = undefined; |
| 220 | + |
| 221 | + /* eslint-enable @typescript-eslint/no-unsafe-member-access */ |
| 222 | + } |
| 223 | + } |
| 224 | + |
| 225 | + /** |
| 226 | + * Increments status bucket in pendingAggregates buffer (internal state) corresponding to status of |
| 227 | + * the session received |
| 228 | + */ |
| 229 | + private _incrementSessionStatusCount(status: RequestSessionStatus, date: Date): number { |
| 230 | + // Truncate minutes and seconds on Session Started attribute to have one minute bucket keys |
| 231 | + const sessionStartedTrunc: number = new Date(date).setSeconds(0, 0); |
| 232 | + this._pendingAggregates[sessionStartedTrunc] = this._pendingAggregates[sessionStartedTrunc] || {}; |
| 233 | + |
| 234 | + // corresponds to aggregated sessions in one specific minute bucket |
| 235 | + // for example, {"started":"2021-03-16T08:00:00.000Z","exited":4, "errored": 1} |
| 236 | + const aggregationCounts: AggregationCounts = this._pendingAggregates[sessionStartedTrunc]; |
| 237 | + if (!aggregationCounts.started) { |
| 238 | + aggregationCounts.started = new Date(sessionStartedTrunc).toISOString(); |
| 239 | + } |
| 240 | + |
| 241 | + switch (status) { |
| 242 | + case RequestSessionStatus.Errored: |
| 243 | + aggregationCounts.errored = aggregationCounts.errored !== undefined ? aggregationCounts.errored + 1 : 1; |
| 244 | + return aggregationCounts.errored; |
| 245 | + case RequestSessionStatus.Ok: |
| 246 | + aggregationCounts.exited = aggregationCounts.exited !== undefined ? aggregationCounts.exited + 1 : 1; |
| 247 | + return aggregationCounts.exited; |
| 248 | + case RequestSessionStatus.Crashed: |
| 249 | + aggregationCounts.crashed = aggregationCounts.crashed !== undefined ? aggregationCounts.crashed + 1 : 1; |
| 250 | + return aggregationCounts.crashed; |
| 251 | + } |
| 252 | + } |
| 253 | +} |
0 commit comments