@gitpod/gitpod-protocol 0.1.5-svenefftinge-patch-1.3 → 0.1.5-tarun-telemetry-users.1

package/src/util/tracing.ts

@@ -6,40 +6,183 @@
 
 
 import * as opentracing from 'opentracing';
-import { TracingConfig, initTracerFromEnv, Sampler, SamplingDecision } from 'jaeger-client';
-import { initGlobalTracer } from 'opentracing';
+import { TracingConfig, initTracerFromEnv } from 'jaeger-client';
+import { Sampler, SamplingDecision } from './jaeger-client-types';
+import { followsFrom, initGlobalTracer } from 'opentracing';
 import { injectable } from 'inversify';
+import { ResponseError } from 'vscode-jsonrpc';
+import { log, LogContext } from './logging';
 
 export interface TraceContext {
     span?: opentracing.Span
 }
+export type TraceContextWithSpan = TraceContext & {
+    span: opentracing.Span
+}
+
 
 export namespace TraceContext {
-    export function startSpan(operation: string, ctx: TraceContext): opentracing.Span {
-        const options: opentracing.SpanOptions = {
-            childOf: ctx.span
+    export function startSpan(operation: string, parentCtx?: TraceContext, ...referencedSpans: (opentracing.Span | undefined)[]): opentracing.Span {
+        const options: opentracing.SpanOptions = {};
+        if (parentCtx && parentCtx.span && !!parentCtx.span.context().toSpanId()) {
+            options.childOf = parentCtx.span;
+        }
+        if (referencedSpans) {
+            // note: allthough followsForm's type says it takes 'opentracing.Span | opentracing.SpanContext', it only works with SpanContext (typing mismatch)
+            // note2: we need to filter out debug spans (spanId === "")
+            options.references = referencedSpans.filter(s => s !== undefined)
+                .filter(s => !!s!.context().toSpanId())
+                .map(s => followsFrom(s!.context()));
         }
+
         return opentracing.globalTracer().startSpan(operation, options);
     }
 
-    export function startAsyncSpan(operation: string, ctx: TraceContext): opentracing.Span {
-        const options: opentracing.SpanOptions = {};
-        if (!!ctx.span) {
-            options.references = [opentracing.followsFrom(ctx.span.context())];
+    export function childContext(operation: string, parentCtx: TraceContext): TraceContextWithSpan {
+        const span = startSpan(operation, parentCtx);
+        return { span };
+    }
+
+    export function withSpan(operation: string, callback: () => void, ctx?: TraceContext, ...referencedSpans: (opentracing.Span | undefined)[]): void {
+        // if we don't have a parent span, don't create a trace here as those <trace-without-root-spans> are not useful.
+        if (!ctx || !ctx.span || !ctx.span.context()) {
+            callback();
+            return;
         }
-        return opentracing.globalTracer().startSpan(operation, options);
+
+        const span = TraceContext.startSpan(operation, ctx, ...referencedSpans);
+        try {
+            callback();
+        } catch (e) {
+            TraceContext.setError({span}, e);
+            throw e;
+        } finally {
+            span.finish();
+        }
+    }
+
+    export function setError(ctx: TraceContext, err: Error) {
+        if (!ctx.span) {
+            return;
+        }
+
+        TraceContext.addNestedTags(ctx, {
+            error: {
+                message: err.message,
+                stacktrace: err.stack,
+            },
+        });
+        ctx.span.setTag("error", true);
+    }
+
+    export function setJsonRPCMetadata(ctx: TraceContext, method?: string) {
+        if (!ctx.span) {
+            return;
+        }
+
+        const tags: { [key: string]: any } = {
+            rpc: {
+                system: "jsonrpc",
+                //  version,
+            },
+        };
+        if (method) {
+            tags.rpc.method = method;
+        }
+        addNestedTags(ctx, tags);
     }
 
-    export function logError(ctx: TraceContext, err: Error) {
+    export function setJsonRPCError(ctx: TraceContext, method: string, err: ResponseError<any>, withStatusCode: boolean = false) {
         if (!ctx.span) {
             return;
         }
+        // not use setError bc this is (most likely) a working operation
 
-        ctx.span.log({
-            "error": err.message,
-            "stacktrace": err.stack
-        })
-        ctx.span.setTag("error", true)
+        setJsonRPCMetadata(ctx, method);
+        // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/rpc.md#json-rpc
+        addNestedTags(ctx, {
+            rpc: {
+                jsonrpc: {
+                    error_code: err.code,
+                    error_message: err.message,
+                },
+            },
+        });
+
+        // the field "status_code" is used by honeycomb to derive insights like success rate, etc. Defaults to "0".
+        if (withStatusCode) {
+            ctx.span.setTag("status_code", err.code);
+        }
+    }
+
+    export function addJsonRPCParameters(ctx: TraceContext, params: { [key: string]: any }) {
+        if (!ctx.span) {
+            return;
+        }
+
+        setJsonRPCMetadata(ctx);
+        addNestedTags(ctx, {
+            rpc: {
+                jsonrpc: {
+                    parameters: params,
+                },
+            },
+        });
+    }
+
+    /**
+     * Does what one would expect from `span.addTags`: Calls `span.addTag` for all keys in map, recursively for objects.
+     * Example:
+     * ```
+     * TraceContext.addNestedTags(ctx, {
+     *    rpc: {
+     *       system: "jsonrpc",
+     *       jsonrpc: {
+     *          version: "1.0",
+     *          method: "test",
+     *          parameters: ["abc", "def"],
+     *       },
+     *    },
+     * });
+     * ```
+     * gives
+     * rpc.system = "jsonrpc"
+     * rpc.jsonrpc.version = "1.0"
+     * rpc.jsonrpc.method = "test"
+     * rpc.jsonrpc.parameters.0 = "abc"
+     * rpc.jsonrpc.parameters.1 = "def"
+     * @param ctx
+     * @param keyValueMap
+     * @returns
+     */
+    export function addNestedTags(ctx: TraceContext, keyValueMap: { [key: string]: any }, _namespace?: string) {
+        if (!ctx.span) {
+            return;
+        }
+        const namespace = _namespace ? `${_namespace}.` : '';
+
+        try {
+            for (const k of Object.keys(keyValueMap)) {
+                const v = keyValueMap[k];
+                if (v instanceof Object) {
+                    addNestedTags(ctx, v, `${namespace}${k}`);
+                } else {
+                    ctx.span.setTag(`${namespace}${k}`, v);
+                }
+            }
+        } catch (err) {
+            // general resilience against odd shapes/parameters
+            log.error("Tracing.addNestedTags", err, { namespace });
+        }
+    }
+
+    export function setOWI(ctx: TraceContext, owi: LogContext) {
+        if (!ctx.span) {
+            return;
+        }
+        addNestedTags(ctx, {
+            context: owi,
+        });
     }
 }
 
@@ -56,11 +199,16 @@ export class TracingManager {
             reporter: {
                 logSpans: false
             },
-            serviceName
+            serviceName,
         }
         const t = initTracerFromEnv(config, {
-            logger: console
+            logger: console,
+            tags: {
+                'service.build.commit': process.env.GITPOD_BUILD_GIT_COMMIT,
+                'service.build.version': process.env.GITPOD_BUILD_VERSION,
+            }
         });
+
         if (opts) {
             if (opts.perOpSampling) {
                 (t as any)._sampler = new PerOperationSampler((t as any)._sampler, opts.perOpSampling);
@@ -132,3 +280,20 @@ export class PerOperationSampler implements Sampler {
         }
     }
 }
+
+// Augment interfaces with an leading parameter "TraceContext" on every method
+type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
+type AddTraceContext<T> =
+    T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F) => infer R ? (
+        IsValidArg<F> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E, f: F) => R :
+        IsValidArg<E> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E) => R :
+        IsValidArg<D> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D) => R :
+        IsValidArg<C> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C) => R :
+        IsValidArg<B> extends true ? (ctx: TraceContextWithSpan, a: A, b: B) => R :
+        IsValidArg<A> extends true ? (ctx: TraceContextWithSpan, a: A) => R :
+        (ctx: TraceContextWithSpan) => Promise<R>
+    ) : never;
+
+export type InterfaceWithTraceContext<T> = {
+    [P in keyof T]: AddTraceContext<T[P]>
+};

package/src/workspace-cluster.ts

@@ -52,9 +52,11 @@ export namespace TLSConfig {
 export type WorkspaceClusterWoTLS = Omit<WorkspaceCluster, "tls">;
 export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "url" | "tls">;
 
-export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole;
+export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole | AdmissionConstraintHasUserLevel | AdmissionConstraintHasMoreResources;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
 export type AdmissionConstraintHasRole = { type: "has-permission", permission: PermissionName };
+export type AdmissionConstraintHasUserLevel = { type: "has-user-level", level: string };
+export type AdmissionConstraintHasMoreResources = { type: "has-more-resources" };
 
 
 export const WorkspaceClusterDB = Symbol("WorkspaceClusterDB");

package/src/workspace-instance.ts

@@ -23,6 +23,9 @@ export interface WorkspaceInstance {
     // The time an instance has switched phase to 'Running'
     startedTime?: string;
 
+    // The time an instance has switched phase to 'Stopping' */
+    stoppingTime?: string;
+
     // The time an instance has switched phase to 'Stopped' */
     stoppedTime?: string;
 
@@ -48,6 +51,11 @@ export interface WorkspaceInstance {
 
     // instance is hard-deleted on the database and about to be collected by db-sync
     readonly deleted?: boolean;
+
+    /**
+     * Contains information about the image build, if there was any
+     */
+     imageBuildInfo?: ImageBuildInfo;
 }
 
 // WorkspaceInstanceStatus describes the current state of a workspace instance
@@ -131,9 +139,6 @@ export interface WorkspaceInstanceConditions {
     // PullingImages marks if the workspace is currently pulling its images. This condition can only be set during PhaseCreating
     pullingImages?: boolean
 
-    // ServiceExists denotes if the workspace theia-/ports- services exist. This condition will be true if either of the two services exist.
-    serviceExists?: boolean
-
     // deployed marks that a workspace instance was sent/deployed at a workspace manager
     deployed?: boolean;
 
@@ -142,6 +147,12 @@ export interface WorkspaceInstanceConditions {
 
     // ISO8601 timestamp when the first user activity was registered in the frontend. Only set if the workspace is running.
     firstUserActivity?: string;
+
+    // headless_task_failed indicates that a headless workspace task failed
+    headlessTaskFailed?: string;
+
+    // stopped_by_request is true if the workspace was stopped using a StopWorkspace call
+    stoppedByRequest?: boolean;
 }
 
 // AdmissionLevel describes who can access a workspace instance and its ports.
@@ -155,9 +166,6 @@ export interface WorkspaceInstancePort {
     // The outward-facing port number
     port: number;
 
-    // An optional inward-facing port number. If not present we'll use port.
-    targetPort?: number;
-
     // The visiblity of this port. Optional for backwards compatibility.
     visibility?: PortVisibility;
 
@@ -203,4 +211,25 @@ export interface WorkspaceInstanceConfiguration {
 
     // ideImage is the ref of the IDE image this instance uses.
     ideImage: string;
+
+    // desktopIdeImage is the ref of the desktop IDE image this instance uses.
+    desktopIdeImage?: string
+
+    // supervisorImage is the ref of the supervisor image this instance uses.
+    supervisorImage?: string;
+}
+
+/**
+ * Holds information about the image build (if there was one) for this WorkspaceInstance
+ */
+export interface ImageBuildInfo {
+    log?: ImageBuildLogInfo,
+}
+
+/**
+ * Holds information about how to access logs for this an image build
+ */
+export interface ImageBuildLogInfo {
+    url: string,
+    headers: { [key: string]: string },
 }

package/src/wsready.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-// generated using github.com/32leaves/bel on 2021-07-01 13:33:23.288163364 +0000 UTC m=+0.012145659
+// generated using github.com/32leaves/bel on 2021-11-04 12:16:53.917570766 +0000 UTC m=+0.006002884
 // DO NOT MODIFY
 
 export enum WorkspaceInitSource {

package/lib/util/repeater.d.ts

@@ -1,22 +0,0 @@
-/**
- * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
- * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
- */
-import { Deferred } from "./deferred";
-/**
- * Repeats a given function until it is stopped
- */
-export declare class Repeater {
-    protected readonly fn: () => Promise<void> | void;
-    protected readonly timeout: number;
-    protected shouldRun: boolean;
-    protected finished: Deferred<void>;
-    protected timer?: any;
-    constructor(fn: () => Promise<void> | void, timeout: number);
-    start(): Promise<void>;
-    run(): Promise<void>;
-    protected sleep(timeout: number): Promise<unknown>;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=repeater.d.ts.map

package/lib/util/repeater.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"repeater.d.ts","sourceRoot":"","sources":["../../src/util/repeater.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC;;GAEG;AACH,qBAAa,QAAQ;IAKL,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAAE,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM;IAJjG,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAClC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC;gBAES,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAAqB,OAAO,EAAE,MAAM;IAE3F,KAAK;IAIL,GAAG;cAcO,KAAK,CAAC,OAAO,EAAE,MAAM;IAI/B,IAAI;CAOb"}

package/lib/util/repeater.js

@@ -1,118 +0,0 @@
-"use strict";
-/**
- * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
- * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repeater = void 0;
-var deferred_1 = require("./deferred");
-var logging_1 = require("./logging");
-/**
- * Repeats a given function until it is stopped
- */
-var Repeater = /** @class */ (function () {
-    function Repeater(fn, timeout) {
-        this.fn = fn;
-        this.timeout = timeout;
-    }
-    Repeater.prototype.start = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.run();
-                return [2 /*return*/];
-            });
-        });
-    };
-    Repeater.prototype.run = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var err_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.shouldRun = true;
-                        this.finished = new deferred_1.Deferred();
-                        _a.label = 1;
-                    case 1:
-                        if (!this.shouldRun) return [3 /*break*/, 7];
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.fn()];
-                    case 3:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _a.sent();
-                        logging_1.log.error(err_1);
-                        return [3 /*break*/, 5];
-                    case 5: return [4 /*yield*/, this.sleep(this.timeout)];
-                    case 6:
-                        _a.sent();
-                        return [3 /*break*/, 1];
-                    case 7:
-                        this.finished.resolve();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Repeater.prototype.sleep = function (timeout) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve) { return _this.timer = setTimeout(resolve, timeout); })];
-            });
-        });
-    };
-    Repeater.prototype.stop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.shouldRun = false;
-                if (this.timer) {
-                    clearTimeout(this.timer);
-                }
-                return [2 /*return*/, this.finished.promise];
-            });
-        });
-    };
-    return Repeater;
-}());
-exports.Repeater = Repeater;
-//# sourceMappingURL=repeater.js.map

package/lib/util/repeater.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"repeater.js","sourceRoot":"","sources":["../../src/util/repeater.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAsC;AACtC,qCAAgC;AAEhC;;GAEG;AACH;IAKI,kBAA+B,EAA8B,EAAqB,OAAe;QAAlE,OAAE,GAAF,EAAE,CAA4B;QAAqB,YAAO,GAAP,OAAO,CAAQ;IAAI,CAAC;IAEhG,wBAAK,GAAX;;;gBACI,IAAI,CAAC,GAAG,EAAE,CAAC;;;;KACd;IAEK,sBAAG,GAAT;;;;;;wBACI,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;wBACtB,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAQ,EAAQ,CAAC;;;6BAC9B,IAAI,CAAC,SAAS;;;;wBAEb,qBAAM,IAAI,CAAC,EAAE,EAAE,EAAA;;wBAAf,SAAe,CAAC;;;;wBAEhB,aAAG,CAAC,KAAK,CAAC,KAAG,CAAC,CAAC;;4BAEnB,qBAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAA;;wBAA9B,SAA8B,CAAC;;;wBAEnC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;;;;;KAC3B;IAEe,wBAAK,GAArB,UAAsB,OAAe;;;;gBACjC,sBAAO,IAAI,OAAO,CAAC,UAAA,OAAO,IAAI,OAAA,KAAI,CAAC,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,EAAzC,CAAyC,CAAC,EAAC;;;KAC5E;IAEK,uBAAI,GAAV;;;gBACI,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,IAAI,CAAC,KAAK,EAAE;oBACZ,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC5B;gBACD,sBAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAC;;;KAChC;IACL,eAAC;AAAD,CAAC,AApCD,IAoCC;AApCY,4BAAQ"}

package/lib/util/safe-promise.d.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
- * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
- */
-import { LogContext } from './logging';
-export declare class SafePromise {
-    static catchAndLog<T>(p: Promise<T>, logCtx?: LogContext): Promise<T>;
-    static catch<T>(p: Promise<T>, handler: (err: any) => void): Promise<T>;
-}
-//# sourceMappingURL=safe-promise.d.ts.map

package/lib/util/safe-promise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"safe-promise.d.ts","sourceRoot":"","sources":["../../src/util/safe-promise.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAO,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,qBAAa,WAAW;WACN,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,UAAU;WASjD,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC;CAMjF"}

package/lib/util/safe-promise.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
- * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SafePromise = void 0;
-var logging_1 = require("./logging");
-var SafePromise = /** @class */ (function () {
-    function SafePromise() {
-    }
-    SafePromise.catchAndLog = function (p, logCtx) {
-        return SafePromise.catch(p, function (err) {
-            if (logCtx) {
-                logging_1.log.error(logCtx, err);
-            }
-            else {
-                logging_1.log.error(err);
-            }
-        });
-    };
-    ;
-    SafePromise.catch = function (p, handler) {
-        return p.catch(function (err) {
-            handler(err);
-            return {}; // Nobody will ever see this value as the Promise already failed. It's just there to please the compiler
-        });
-    };
-    ;
-    return SafePromise;
-}());
-exports.SafePromise = SafePromise;
-//# sourceMappingURL=safe-promise.js.map

package/lib/util/safe-promise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"safe-promise.js","sourceRoot":"","sources":["../../src/util/safe-promise.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAGH,qCAA4C;AAE5C;IAAA;IAgBA,CAAC;IAfiB,uBAAW,GAAzB,UAA6B,CAAa,EAAE,MAAmB;QAC3D,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,UAAC,GAAG;YAC5B,IAAI,MAAM,EAAE;gBACR,aAAG,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;aAC1B;iBAAM;gBACH,aAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;aAClB;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAAA,CAAC;IACY,iBAAK,GAAnB,UAAuB,CAAa,EAAE,OAA2B;QAC7D,OAAO,CAAC,CAAC,KAAK,CAAC,UAAC,GAAG;YACf,OAAO,CAAC,GAAG,CAAC,CAAC;YACb,OAAO,EAAO,CAAC,CAAC,wGAAwG;QAC5H,CAAC,CAAC,CAAC;IACP,CAAC;IAAA,CAAC;IACN,kBAAC;AAAD,CAAC,AAhBD,IAgBC;AAhBY,kCAAW"}

package/src/util/jaeger-client.d.ts

@@ -1,105 +0,0 @@
-/**
- * Copyright (c) 2020 Gitpod GmbH. All rights reserved.
- * Licensed under the GNU Affero General Public License (AGPL).
- * See License-AGPL.txt in the project root for license information.
- */
-
-// Type definitions for jaeger-client
-// Project: https://github.com/uber/jaeger-client-node
-// Definitions by: Julian Steger <https://github.com/julianste>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-declare module 'jaeger-client' {
-    import * as opentracing from "opentracing";
-
-    export interface TracingConfig {
-        serviceName?: string;
-        disable?: boolean;
-        sampler?: SamplerConfig;
-        reporter?: ReporterConfig;
-    }
-
-    export interface TracingOptions {
-        reporter?: Reporter;
-        metrics?: MetricsFactory;
-        logger?: Logger;
-        tags?: any;
-    }
-
-    export interface ReporterConfig {
-        logSpans?: boolean;
-        agentHost?: string;
-        agentPort?: number;
-        flushIntervalMs?: number;
-    }
-
-    export interface SamplerConfig {
-        type: string;
-        param: number;
-        host?: string;
-        port?: number;
-        refreshIntervalMs?: number;
-    }
-
-    export interface Logger {
-        info(msg: string): void;
-        error(msg: string): void;
-    }
-
-    export interface Reporter {
-        report(span: opentracing.Span): void;
-        close(callback?: () => void): void;
-        setProcess(serviceName: string, tags: any): void;
-    }
-
-    export interface MetricsFactory {
-        createCounter(name: string, tags: any): Counter;
-        createTimer(name: string, tags: any): Timer;
-        createGauge(name: string, tags: any): Gauge;
-    }
-
-    // Counter tracks the number of times an event has occurred
-    export interface Counter {
-        // Adds the given value to the counter.
-        increment(delta: number): void;
-    }
-
-    // Timer tracks how long an operation took and also computes percentiles.
-    export interface Timer {
-        // Records the time passed in.
-        record(value: number): void;
-    }
-
-    // Gauge returns instantaneous measurements of something as an int64 value
-    export interface Gauge {
-        // Update the gauge to the value passed in.
-        update(value: number): void;
-    }
-
-    export function initTracer(
-        tracingConfig: TracingConfig,
-        tracingOptions: TracingOptions,
-    ): opentracing.Tracer;
-
-    export function initTracerFromEnv(
-        tracingConfig: TracingConfig,
-        tracingOptions: TracingOptions,
-    ): opentracing.Tracer;
-
-    export interface SamplingDecision {
-        sample: boolean;
-        retryable: boolean;
-        tags: any;
-    }
-
-    // added by TypeFox
-    export interface Sampler {
-        name(): string
-        isSampled(operation: string, tags: any): boolean;
-        onCreateSpan(span: opentracing.Span): SamplingDecision;
-        onSetOperationName(span: opentracing.Span, operationName: string): SamplingDecision;
-        onSetTag(span: opentracing.Span, key: string, value: any): SamplingDecision;
-        close(callback: () => void): void
-    }
-
-}