@gitpod/gitpod-protocol 0.1.5-private-repos-after-cancellation.0 → 0.1.5-protected-secrets.0

package/src/util/tracing.ts

@@ -4,48 +4,192 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
-import * as opentracing from 'opentracing';
-import { TracingConfig, initTracerFromEnv, Sampler, SamplingDecision } from 'jaeger-client';
-import { initGlobalTracer } from 'opentracing';
-import { injectable } from 'inversify';
+import * as opentracing from "opentracing";
+import { TracingConfig, initTracerFromEnv } from "jaeger-client";
+import { Sampler, SamplingDecision } from "./jaeger-client-types";
+import { initGlobalTracer } from "opentracing";
+import { injectable } from "inversify";
+import { ResponseError } from "vscode-jsonrpc";
+import { log, LogContext } from "./logging";
 
 export interface TraceContext {
-    span?: opentracing.Span
+    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): opentracing.Span {
+        const options: opentracing.SpanOptions = {};
+
+        // references should contain span id.
+        // cf. https://github.com/jaegertracing/jaeger-client-node/issues/432
+        if (!!parentCtx?.span) {
+            const ctx = parentCtx?.span?.context();
+            if (ctx && !!ctx.toTraceId() && !!ctx.toSpanId()) {
+                options.references = [opentracing.followsFrom(ctx)];
+            }
         }
+
         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: (ctx: TraceContext) => void, ctx?: TraceContext): 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;
+        }
+
+        const span = TraceContext.startSpan(operation, ctx);
+        try {
+            callback({ span });
+        } 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 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
+
+        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);
         }
-        return opentracing.globalTracer().startSpan(operation, options);
     }
 
-    export function logError(ctx: TraceContext, err: Error) {
+    export function addJsonRPCParameters(ctx: TraceContext, params: { [key: string]: any }) {
         if (!ctx.span) {
             return;
         }
 
-        ctx.span.log({
-            "error": err.message,
-            "stacktrace": err.stack
-        })
-        ctx.span.setTag("error", true)
+        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,
+        });
     }
 }
 
 @injectable()
 export class TracingManager {
-
     public setup(serviceName: string, opts?: CustomTracerOpts) {
         initGlobalTracer(this.getTracerForService(serviceName, opts));
     }
@@ -54,13 +198,18 @@ export class TracingManager {
         const config: TracingConfig = {
             disable: false,
             reporter: {
-                logSpans: false
+                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);
@@ -68,24 +217,22 @@ export class TracingManager {
         }
         return t;
     }
-
 }
 
 export interface CustomTracerOpts {
-    perOpSampling?: PerOperationSampling
+    perOpSampling?: PerOperationSampling;
 }
 
-
 // has to conform to https://github.com/jaegertracing/jaeger-client-node/blob/0042b1c0a0796bb655eb93e77ff76ab5e94c2bb6/src/_flow/sampler-thrift.js#L32
 export interface PerOperationSampling {
-    [key: string]: boolean
+    [key: string]: boolean;
 }
 
 export class PerOperationSampler implements Sampler {
     constructor(protected readonly fallback: Sampler, protected readonly strategies: PerOperationSampling) {}
 
     name(): string {
-        return 'PerOperationSampler';
+        return "PerOperationSampler";
     }
 
     toString(): string {
@@ -125,10 +272,32 @@ export class PerOperationSampler implements Sampler {
         return false; // TODO equal should be removed
     }
 
-    close(callback: ()=>void): void {
+    close(callback: () => void): void {
         // all nested samplers are of simple types, so we do not need to Close them
         if (callback) {
             callback();
         }
     }
 }
+
+// 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/util/workspace-port-authentication.ts

@@ -5,16 +5,13 @@
  */
 
 /**
-* These cookies are set in the Theia frontend. This pattern is relied upon in:
-*  - proxy:
-*    - to filter it out on port locations
-*    - to forward it to the server for authentication
-*  - server:
-*    - to authenticate access to port locations
-*/
-export const worspacePortAuthCookieName = function(host: string, workspaceId: string): string {
-    return host
-        .replace(/https?/, '')
-        .replace(/[\W_]+/g, "_")
-        + `_ws_${workspaceId}_port_auth_`;
-};
+ * These cookies are set in the Theia frontend. This pattern is relied upon in:
+ *  - proxy:
+ *    - to filter it out on port locations
+ *    - to forward it to the server for authentication
+ *  - server:
+ *    - to authenticate access to port locations
+ */
+export const worspacePortAuthCookieName = function (host: string, workspaceId: string): string {
+    return host.replace(/https?/, "").replace(/[\W_]+/g, "_") + `_ws_${workspaceId}_port_auth_`;
+};

package/src/webhook-event.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2022 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.
+ */
+
+export interface WebhookEvent {
+    id: string;
+    creationTime: string;
+    type: "push" | string;
+
+    /**
+     * Typically the webhook installer is referenced here.
+     */
+    authorizedUserId?: string;
+
+    /**
+     * webhook event's payload
+     */
+    rawEvent: string;
+
+    /**
+     * The general status of the received webhook event.
+     */
+    status: WebhookEvent.Status;
+
+    /**
+     * Optional message to help understand errors with handling events.
+     */
+    message?: string;
+
+    /**
+     * If the webhook event is considered to trigger a prebuild, the `prebuildStatus`
+     * contains a more specific status.
+     */
+    prebuildStatus?: WebhookEvent.PrebuildStatus;
+
+    /**
+     * If `prebuildStatus` is `prebuild_triggered` this points to a prebuild.
+     */
+    prebuildId?: string;
+
+    projectId?: string;
+
+    cloneUrl?: string;
+
+    branch?: string;
+
+    commit?: string;
+}
+
+export namespace WebhookEvent {
+    export type Status = "received" | "dismissed_unauthorized" | "ignored" | "processed";
+    export type PrebuildStatus = "ignored_unconfigured" | "prebuild_trigger_failed" | "prebuild_triggered";
+}

package/src/workspace-class.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2022 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.
+ */
+
+export interface SupportedWorkspaceClass {
+    id: string;
+    category: string;
+    displayName: string;
+    description: string;
+    powerups: number;
+    isSelected: boolean;
+}

package/src/workspace-cluster.ts

@@ -4,11 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as fs from 'fs';
-import { filePathTelepresenceAware } from './env';
+import * as fs from "fs";
+import { filePathTelepresenceAware } from "./env";
 import { DeepPartial } from "./util/deep-partial";
-import { Without } from './util/without';
-import { PermissionName } from './permission';
+import { PermissionName } from "./permission";
 
 export interface WorkspaceCluster {
     // Name of the workspace cluster.
@@ -16,6 +15,10 @@ export interface WorkspaceCluster {
     // Must be identical to the installationShortname of the cluster it represents!
     name: string;
 
+    // The name of the application cluster to which this cluster should be registered.
+    // The name can be at most 60 characters.
+    applicationCluster: string;
+
     // URL of the cluster's ws-manager API
     url: string;
 
@@ -48,15 +51,31 @@ export interface TLSConfig {
     crt: string;
 }
 export namespace TLSConfig {
-    export const loadFromBase64File = (path: string): string => fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
+    export const loadFromBase64File = (path: string): string =>
+        fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
 }
-export type WorkspaceClusterWoTLS = Without<WorkspaceCluster, "tls">;
+export type WorkspaceClusterWoTLS = Omit<WorkspaceCluster, "tls">;
 export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "url" | "tls">;
 
-export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole;
+export type AdmissionConstraint =
+    | AdmissionConstraintFeaturePreview
+    | AdmissionConstraintHasPermission
+    | AdmissionConstraintHasClass;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
-export type AdmissionConstraintHasRole = { type: "has-permission", permission: PermissionName };
-
+export type AdmissionConstraintHasPermission = { type: "has-permission"; permission: PermissionName };
+export type AdmissionConstraintHasClass = { type: "has-class"; id: string; displayName: string };
+
+export namespace AdmissionConstraint {
+    export function is(o: any): o is AdmissionConstraint {
+        return !!o && "type" in o;
+    }
+    export function isHasPermissionConstraint(o: any): o is AdmissionConstraintHasPermission {
+        return is(o) && o.type === "has-permission";
+    }
+    export function hasPermission(ac: AdmissionConstraint, permission: PermissionName): boolean {
+        return isHasPermissionConstraint(ac) && ac.permission === permission;
+    }
+}
 
 export const WorkspaceClusterDB = Symbol("WorkspaceClusterDB");
 export interface WorkspaceClusterDB {
@@ -87,4 +106,4 @@ export interface WorkspaceClusterDB {
 }
 export interface WorkspaceClusterFilter extends Pick<WorkspaceCluster, "state" | "govern" | "url"> {
     minScore: number;
-}
+}

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,10 +51,32 @@ 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;
+
+    /**
+     * workspace class, also known as workspace size, determines the type of
+     * resources that are provided to the workspace.
+     */
+    workspaceClass?: string;
+
+    /**
+     * Identifies the team or user to which this instance's runtime should be attributed to
+     * (e.g. for usage analytics or billing purposes).
+     */
+    usageAttributionId?: string;
 }
 
 // WorkspaceInstanceStatus describes the current state of a workspace instance
 export interface WorkspaceInstanceStatus {
+    // version is the current version of the workspace instance status
+    // Note: consider this value opague. The only guarantee given is that it imposes
+    //       a partial order on status updates, i.e. a.version > b.version -> a newer than b.
+    version?: number;
+
     // phase describes a high-level state of the workspace instance
     phase: WorkspaceInstancePhase;
 
@@ -87,52 +112,54 @@ export interface WorkspaceInstanceStatus {
 export type WorkspaceInstancePhase =
     // unknown indicates an issue within the system in that it cannot determine the actual phase of
     // a workspace. This phase is usually accompanied by an error.
-    "unknown" |
+    | "unknown"
 
     // Preparing means that we haven't actually started the workspace instance just yet, but rather
-    // are still preparing for launch. This means we're building the Docker image for the workspace.
-    "preparing" |
+    // are still preparing for launch.
+    | "preparing"
+
+    // Building means that we are building the Docker image for the workspace. A workspace will enter this phase only
+    // if an image build is required for that workspace.
+    | "building"
 
     // Pending means the workspace does not yet consume resources in the cluster, but rather is looking for
     // some space within the cluster. If for example the cluster needs to scale up to accomodate the
     // workspace, the workspace will be in Pending state until that happened.
-    "pending" |
+    | "pending"
 
     // Creating means the workspace is currently being created. Thati includes downloading the images required
     // to run the workspace over the network. The time spent in this phase varies widely and depends on the current
     // network speed, image size and cache states.
-    "creating" |
+    | "creating"
 
     // Initializing is the phase in which the workspace is executing the appropriate workspace initializer (e.g. Git
     // clone or backup download). After this phase one can expect the workspace to either be Running or Failed.
-    "initializing" |
+    | "initializing"
 
     // Running means the workspace is able to actively perform work, either by serving a user through Theia,
     // or as a headless workspace.
-    "running" |
+    | "running"
 
     // Interrupted is an exceptional state where the container should be running but is temporarily unavailable.
     // When in this state, we expect it to become running or stopping anytime soon.
-    "interrupted" |
+    | "interrupted"
 
     // Stopping means that the workspace is currently shutting down. It could go to stopped every moment.
-    "stopping" |
+    | "stopping"
 
     // Stopped means the workspace ended regularly because it was shut down.
-    "stopped";
+    | "stopped";
 
 export interface WorkspaceInstanceConditions {
     // Failed contains the reason the workspace failed to operate. If this field is empty, the workspace has not failed.
-    failed?: string
+    // failed contains technical details for the failure of the workspace.
+    failed?: string;
 
     // timeout contains the reason the workspace has timed out. If this field is empty, the workspace has not timed out.
-    timeout?: string
+    timeout?: string;
 
     // 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
+    pullingImages?: boolean;
 
     // deployed marks that a workspace instance was sent/deployed at a workspace manager
     deployed?: boolean;
@@ -142,22 +169,28 @@ export interface WorkspaceInstanceConditions {
 
     // ISO8601 timestamp when the first user activity was registered in the frontend. Only set if the workspace is running.
     firstUserActivity?: string;
+
+    // headlessTaskFailed indicates that a headless workspace task failed
+    // headlessTaskFailed is only set if:
+    //  * this workspace is headless
+    //  * the task being run returned a non 0 exit status code
+    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.
-export type AdmissionLevel = 'owner_only' | 'everyone';
+export type AdmissionLevel = "owner_only" | "everyone";
 
 // PortVisibility describes how a port can be accessed
-export type PortVisibility = 'public' | 'private';
+export type PortVisibility = "public" | "private";
 
 // WorkspaceInstancePort describes a port exposed on a workspace instance
 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;
 
@@ -177,19 +210,25 @@ export interface WorkspaceInstanceRepoStatus {
     uncommitedFiles?: string[];
 
     // the total number of uncommited files
-    totalUncommitedFiles?: number
+    totalUncommitedFiles?: number;
 
     // untrackedFiles is the list of untracked files in the workspace, possibly truncated
     untrackedFiles?: string[];
 
     // the total number of untracked files
-    totalUntrackedFiles?: number
+    totalUntrackedFiles?: number;
 
     // unpushedCommits is the list of unpushed changes in the workspace, possibly truncated
     unpushedCommits?: string[];
 
     // the total number of unpushed changes
-    totalUnpushedCommits?: number
+    totalUnpushedCommits?: number;
+}
+
+// ConfigurationIdeConfig ide config of WorkspaceInstanceConfiguration
+export interface ConfigurationIdeConfig {
+    useLatest?: boolean;
+    desktopIdeAlias?: string;
 }
 
 // WorkspaceInstanceConfiguration contains all per-instance configuration
@@ -203,4 +242,30 @@ 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;
+
+    // desktopIdePluginImage is the ref of the desktop IDE plugin image this instance uses.
+    desktopIdePluginImage?: string;
+
+    // supervisorImage is the ref of the supervisor image this instance uses.
+    supervisorImage?: string;
+
+    ideConfig?: ConfigurationIdeConfig;
+}
+
+/**
+ * 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 };
 }