@gitpod/gitpod-protocol 0.1.5-tar-telemetry-settings-data.2 → 0.1.5-tar-sh-active-users.8

package/src/snapshot-url.spec.ts

@@ -4,16 +4,18 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { suite, test } from "mocha-typescript"
-import * as chai from "chai"
+import { suite, test } from "mocha-typescript";
+import * as chai from "chai";
 import { SnapshotUrl } from ".";
 
-const expect = chai.expect
-
-@suite class TestSnapshotUrlParser {
+const expect = chai.expect;
 
+@suite
+class TestSnapshotUrlParser {
     @test public testPositive() {
-        const actual = SnapshotUrl.parse("workspaces/c362d434-6faa-4ce0-9ad4-91b4a87c4abe/3f0556f7-4afa-11e9-98d5-52f8983b9279.tar@gitpod-prodcopy-user-e1e28f18-0354-4a5d-b6b4-8879a2ff73fd");
+        const actual = SnapshotUrl.parse(
+            "workspaces/c362d434-6faa-4ce0-9ad4-91b4a87c4abe/3f0556f7-4afa-11e9-98d5-52f8983b9279.tar@gitpod-prodcopy-user-e1e28f18-0354-4a5d-b6b4-8879a2ff73fd",
+        );
 
         expect(actual).to.deep.equal(<SnapshotUrl>{
             bucketId: "gitpod-prodcopy-user-e1e28f18-0354-4a5d-b6b4-8879a2ff73fd",
@@ -22,4 +24,4 @@ const expect = chai.expect
         });
     }
 }
-module.exports = new TestSnapshotUrlParser()   // Only to circumvent no usage warning :-/
+module.exports = new TestSnapshotUrlParser(); // Only to circumvent no usage warning :-/

package/src/team-subscription-protocol.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 import { Subscription } from "./accounting-protocol";
 
 export interface TeamSubscription {
@@ -18,16 +18,45 @@ export interface TeamSubscription {
     paymentReference: string;
     cancellationDate?: string;
     deleted?: boolean;
+    /** If this flag is set slots are not eligibile for clusters with "more-resources" - even if their plan might be */
+    excludeFromMoreResources: boolean;
 }
 
 export namespace TeamSubscription {
-    export const create = (ts: Omit<TeamSubscription, 'id'>): TeamSubscription => {
+    export const create = (ts: Omit<TeamSubscription, "id">): TeamSubscription => {
         const withId = ts as TeamSubscription;
         withId.id = uuidv4();
         return withId;
-    }
+    };
     export const isActive = (ts: TeamSubscription, date: string): boolean => {
         return ts.startDate <= date && (ts.endDate === undefined || date < ts.endDate);
+    };
+}
+
+export interface TeamSubscription2 {
+    id: string;
+    teamId: string;
+    planId: string;
+    startDate: string;
+    endDate?: string;
+    quantity: number;
+    /** The Chargebee subscription id */
+    paymentReference: string;
+    cancellationDate?: string;
+    excludeFromMoreResources: boolean;
+}
+
+export namespace TeamSubscription2 {
+    export const create = (ts2: Omit<TeamSubscription2, "id">): TeamSubscription2 => {
+        const withId = ts2 as TeamSubscription2;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
+        return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
+    };
+    export function isCancelled(s: TeamSubscription2, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
     }
 }
 
@@ -42,49 +71,57 @@ export interface TeamSubscriptionSlot {
     subscriptionId?: string;
     cancellationDate?: string;
 }
-export type TeamSubscriptionSlotDeactivated = TeamSubscriptionSlot & { assigneeId: string, assigneeIdentifier: AssigneeIdentifier };
-export type TeamSubscriptionSlotAssigned = TeamSubscriptionSlot & TeamSubscriptionSlotDeactivated & { subscriptionId: string };
+export type TeamSubscriptionSlotDeactivated = TeamSubscriptionSlot & {
+    assigneeId: string;
+    assigneeIdentifier: AssigneeIdentifier;
+};
+export type TeamSubscriptionSlotAssigned = TeamSubscriptionSlot &
+    TeamSubscriptionSlotDeactivated & { subscriptionId: string };
 
-export type TeamSubscriptionSlotState = 'unassigned' | 'assigned' | 'deactivated' | 'cancelled';
+export type TeamSubscriptionSlotState = "unassigned" | "assigned" | "deactivated" | "cancelled";
 
 export namespace TeamSubscriptionSlot {
-    export const create = (ts: Omit<TeamSubscriptionSlot, 'id'>): TeamSubscriptionSlot => {
+    export const create = (ts: Omit<TeamSubscriptionSlot, "id">): TeamSubscriptionSlot => {
         const withId = ts as TeamSubscriptionSlot;
         withId.id = uuidv4();
         return withId;
-    }
-    export const assign = (slot: TeamSubscriptionSlot, assigneeId: string, subscriptionId: string, assigneeIdentifier: AssigneeIdentifier) => {
+    };
+    export const assign = (
+        slot: TeamSubscriptionSlot,
+        assigneeId: string,
+        subscriptionId: string,
+        assigneeIdentifier: AssigneeIdentifier,
+    ) => {
         slot.assigneeId = assigneeId;
         slot.subscriptionId = subscriptionId;
         slot.assigneeIdentifier = assigneeIdentifier;
-    }
+    };
     export const deactivate = (slot: TeamSubscriptionSlot, cancellationDate: string) => {
         slot.subscriptionId = undefined;
         slot.cancellationDate = cancellationDate;
-    }
+    };
     export const reactivate = (slot: TeamSubscriptionSlot, subscriptionId?: string) => {
         slot.subscriptionId = subscriptionId;
         slot.cancellationDate = undefined;
-    }
+    };
     export const status = (slot: TeamSubscriptionSlot, now: string): TeamSubscriptionSlotState => {
         if (slot.cancellationDate) {
             if (slot.cancellationDate < now) {
-                return 'cancelled';
+                return "cancelled";
             } else {
-                return 'deactivated';
+                return "deactivated";
             }
         } else {
             if (slot.subscriptionId) {
-                return 'assigned';
+                return "assigned";
             } else {
-                return 'unassigned';
+                return "unassigned";
             }
         }
-
-    }
+    };
     export const isActive = (slot: TeamSubscriptionSlot): boolean => {
         return !slot.cancellationDate;
-    }
+    };
 }
 
 /**
@@ -107,7 +144,7 @@ export interface TeamSubscriptionSlotResolved {
 export type AssigneeIdentifier = AssigneeIdentityIdentifier;
 export interface AssigneeIdentityIdentifier {
     identity: {
-        authHost: string,
-        authName: string
-    }
+        authHost: string;
+        authName: string;
+    };
 }

package/src/teams-projects-protocol.ts

@@ -5,15 +5,18 @@
  */
 
 import { PrebuiltWorkspaceState } from "./protocol";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 import { DeepPartial } from "./util/deep-partial";
+import { WebhookEvent } from "./webhook-event";
 
 export interface ProjectConfig {
-    '.gitpod.yml': string;
+    ".gitpod.yml": string;
 }
 
 export interface ProjectSettings {
     useIncrementalPrebuilds?: boolean;
+    usePersistentVolumeClaim?: boolean;
+    keepOutdatedPrebuildsRunning?: boolean;
 }
 
 export interface Project {
@@ -33,13 +36,13 @@ export interface Project {
 }
 
 export namespace Project {
-    export const create = (project: Omit<Project, 'id' | 'creationTime'>): Project => {
+    export const create = (project: Omit<Project, "id" | "creationTime">): Project => {
         return {
             ...project,
             id: uuidv4(),
-            creationTime: new Date().toISOString()
+            creationTime: new Date().toISOString(),
         };
-    }
+    };
 
     export interface Overview {
         branches: BranchDetails[];
@@ -67,7 +70,12 @@ export namespace Project {
     }
 }
 
-export type PartialProject = DeepPartial<Project> & Pick<Project, 'id'>;
+export type PartialProject = DeepPartial<Project> & Pick<Project, "id">;
+
+export interface ProjectUsage {
+    lastWebhookReceived: string;
+    lastWorkspaceStart: string;
+}
 
 export interface PrebuildWithStatus {
     info: PrebuildInfo;
@@ -103,7 +111,7 @@ export interface PrebuildInfo {
 }
 export namespace PrebuildInfo {
     export function is(data?: any): data is PrebuildInfo {
-        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every(p => p in data);
+        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every((p) => p in data);
     }
 }
 
@@ -144,4 +152,16 @@ export interface TeamMembershipInvite {
 
     /** This is a flag that triggers the HARD DELETION of this entity */
     deleted?: boolean;
-}
+}
+
+export interface PrebuildEvent {
+    id: string;
+    creationTime: string;
+    status: WebhookEvent.Status | WebhookEvent.PrebuildStatus;
+    message?: string;
+    prebuildId?: string;
+    projectId?: string;
+    cloneUrl?: string;
+    branch?: string;
+    commit?: string;
+}

package/src/typings/globals.ts

@@ -6,7 +6,7 @@
 
 interface Window {
     gitpod: {
-        service: import('../gitpod-service').GitpodService
-        ideService?: import('../ide-frontend-service').IDEFrontendService
-    }
-}
+        service: import("../gitpod-service").GitpodService;
+        ideService?: import("../ide-frontend-service").IDEFrontendService;
+    };
+}

package/src/usage.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+import { User, WorkspaceType } from "./protocol";
+
+export interface BillableSession {
+    // The id of the one paying the bill
+    attributionId: string;
+
+    // Relevant for workspace type. When prebuild, shows "prebuild"
+    userId?: string;
+    teamId?: string;
+
+    instanceId: string;
+
+    workspaceId: string;
+
+    workspaceType: BillableWorkspaceType;
+
+    workspaceClass: string;
+
+    // When the workspace started
+    startTime: string;
+
+    // When the workspace ended. Not set when the workspace is still running.
+    endTime?: string;
+
+    // The credits used for this session
+    credits: number;
+
+    // TODO - maybe
+    projectId?: string;
+}
+
+export interface ExtendedBillableSession extends BillableSession {
+    contextURL?: string;
+    user?: Pick<User.Profile, "name" | "avatarURL">;
+}
+
+/**
+ * This is a paginated request
+ */
+export interface ListBilledUsageRequest {
+    attributionId: string;
+    fromDate?: number;
+    toDate?: number;
+    perPage: number;
+    page: number;
+}
+
+export interface ListBilledUsageResponse {
+    sessions: ExtendedBillableSession[];
+    totalCreditsUsed: number;
+    totalPages: number;
+    totalSessions: number;
+    perPage: number;
+    page: number;
+}
+
+export type BillableWorkspaceType = WorkspaceType;

package/src/util/analytics.ts

@@ -6,8 +6,7 @@
 
 import Analytics = require("analytics-node");
 import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
-import { log } from './logging';
-
+import { log } from "./logging";
 
 export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
     switch (process.env.GITPOD_ANALYTICS_WRITER) {
@@ -21,20 +20,28 @@ export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
 }
 
 class SegmentAnalyticsWriter implements IAnalyticsWriter {
-
     protected readonly analytics: Analytics;
 
     constructor(writeKey: string) {
         this.analytics = new Analytics(writeKey);
     }
 
-        identify(msg: IdentifyMessage) {
+    identify(msg: IdentifyMessage) {
         try {
-            this.analytics.identify(msg, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.identify failed", err);
-                }
-            });
+            this.analytics.identify(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.identify failed", err);
+                    }
+                },
+            );
         } catch (err) {
             log.warn("analytics.identify failed", err);
         }
@@ -42,32 +49,48 @@ class SegmentAnalyticsWriter implements IAnalyticsWriter {
 
     track(msg: TrackMessage) {
         try {
-            this.analytics.track(msg, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.track failed", err);
-                }
-            });
+            this.analytics.track(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.track failed", err);
+                    }
+                },
+            );
         } catch (err) {
             log.warn("analytics.track failed", err);
         }
     }
 
     page(msg: PageMessage) {
-        try{
-            this.analytics.page(msg, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.page failed", err);
-                }
-            });
+        try {
+            this.analytics.page(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.page failed", err);
+                    }
+                },
+            );
         } catch (err) {
             log.warn("analytics.page failed", err);
         }
     }
-
 }
 
 class LogAnalyticsWriter implements IAnalyticsWriter {
-
     identify(msg: IdentifyMessage): void {
         log.debug("analytics identify", msg);
     }
@@ -77,11 +100,10 @@ class LogAnalyticsWriter implements IAnalyticsWriter {
     page(msg: PageMessage): void {
         log.debug("analytics page", msg);
     }
-
 }
 
 class NoAnalyticsWriter implements IAnalyticsWriter {
     identify(msg: IdentifyMessage): void {}
     track(msg: TrackMessage): void {}
     page(msg: PageMessage): void {}
-}
+}

package/src/util/async-iterator.ts

@@ -5,8 +5,8 @@
  */
 
 // Use asyncIterators with es2015
-if (typeof (Symbol as any).asyncIterator === 'undefined') {
-    (Symbol as any).asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator');
+if (typeof (Symbol as any).asyncIterator === "undefined") {
+    (Symbol as any).asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
 }
 
 export async function find<T>(it: AsyncIterableIterator<T>, predicate: (value: T) => boolean): Promise<T | undefined> {
@@ -31,12 +31,11 @@ export interface AsyncCachingIterator<T> extends AsyncIterableIterator<T> {
     resetCursor(): void;
 }
 export class AsyncCachingIteratorImpl<T> implements AsyncIterableIterator<T>, AsyncCachingIterator<T> {
-
     protected cache: T[] = [];
     protected cursor = 0;
     protected cacheRead = false;
 
-    constructor(protected readonly iterable: AsyncIterableIterator<T>) { }
+    constructor(protected readonly iterable: AsyncIterableIterator<T>) {}
 
     public resetCursor() {
         this.cursor = 0;
@@ -47,7 +46,7 @@ export class AsyncCachingIteratorImpl<T> implements AsyncIterableIterator<T>, As
         if (!this.cacheRead && this.cursor < this.cache.length) {
             return {
                 done: false,
-                value: this.cache[this.cursor++]
+                value: this.cache[this.cursor++],
             };
         }
         this.cacheRead = true;

package/src/util/cancelable.ts

@@ -9,10 +9,10 @@ import { Disposable } from "./disposable";
 export class Cancelable<T> implements Disposable {
     protected canceled: boolean;
 
-    constructor(protected readonly activity: (cancel: boolean) => Promise<T> | undefined) { }
+    constructor(protected readonly activity: (cancel: boolean) => Promise<T> | undefined) {}
 
     public async run(): Promise<T | undefined> {
-        for(let r = await this.activity(this.canceled); ; r = await this.activity(this.canceled)) {
+        for (let r = await this.activity(this.canceled); ; r = await this.activity(this.canceled)) {
             if (this.canceled) {
                 return;
             } else if (r !== undefined) {
@@ -28,4 +28,4 @@ export class Cancelable<T> implements Disposable {
     dispose(): void {
         this.cancel();
     }
-}
+}

package/src/util/date-time.ts

@@ -5,26 +5,26 @@
  */
 
 export function formatDate(date?: string) {
-    return date ? new Date(date).toLocaleString() : '';
+    return date ? new Date(date).toLocaleString() : "";
 }
 
 export function formatHours(hours?: number) {
     if (hours === undefined) {
-        return '';
+        return "";
     }
     const h = Math.floor(Math.abs(hours));
-    const rm = (Math.abs(hours) - h) * 60.;
+    const rm = (Math.abs(hours) - h) * 60;
     const m = Math.floor(rm);
-    const rs = (rm - m) * 60.;
+    const rs = (rm - m) * 60;
     const s = Math.floor(rs);
-    const result = h + ':' + pad2(m) + ':' + pad2(s);
+    const result = h + ":" + pad2(m) + ":" + pad2(s);
     if (hours < 0) {
-        return `-${result}`
+        return `-${result}`;
     } else {
-        return `${result}`
+        return `${result}`;
     }
 }
 
 function pad2(n: number) {
-    return n  < 10 ? '0' + n : '' + n;
+    return n < 10 ? "0" + n : "" + n;
 }

package/src/util/debug-app.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2021 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 * as http from "http";
+import * as express from "express";
+import { injectable, postConstruct } from "inversify";
+import { log, LogrusLogLevel } from "./logging";
+
+export interface SetLogLevelRequest {
+    level: LogrusLogLevel;
+}
+export namespace SetLogLevelRequest {
+    export function is(o: any): o is SetLogLevelRequest {
+        return typeof o === "object" && "level" in o;
+    }
+}
+
+@injectable()
+export class DebugApp {
+    protected _app: express.Application;
+    protected httpServer: http.Server | undefined = undefined;
+
+    @postConstruct()
+    public ctor() {
+        this._app = this.create();
+    }
+
+    create(): express.Application {
+        const app = express();
+
+        app.use(express.json());
+        app.use(express.urlencoded({ extended: true }));
+
+        app.post("/debug/logging", (req, res) => {
+            try {
+                const levelRequest = req.body;
+                if (!SetLogLevelRequest.is(levelRequest)) {
+                    res.status(400).end("not a SetLogLevelRequest");
+                    return;
+                }
+
+                const newLogLevel = levelRequest.level;
+                log.setLogLevel(newLogLevel);
+                log.info("set log level", { newLogLevel });
+                res.status(200).end(JSON.stringify(levelRequest));
+            } catch (err) {
+                res.status(500).end(err);
+            }
+        });
+        return app;
+    }
+
+    public start(port: number = 6060) {
+        this.httpServer = this._app.listen(port, "localhost", () => {
+            log.info(`debug server listening on port: ${port}`);
+        });
+    }
+
+    public async stop() {
+        const server = this.httpServer;
+        if (!server) {
+            return;
+        }
+        return new Promise<void>((resolve) =>
+            server.close((err: any) => {
+                if (err) {
+                    log.warn(`error while closing http server`, { err });
+                }
+                this.httpServer = undefined;
+                resolve();
+            }),
+        );
+    }
+
+    public get app(): express.Application {
+        return this._app;
+    }
+}

package/src/util/deferred.ts

@@ -19,12 +19,12 @@ export class Deferred<T> {
     promise = new Promise<T>((resolve, reject) => {
         this.resolve = (o) => {
             this.isResolved = true;
-            resolve(o as any)
-            clearTimeout(this.timer)
+            resolve(o as any);
+            clearTimeout(this.timer);
         };
         this.reject = (e) => {
-            reject(e)
-            clearTimeout(this.timer)
-        }
+            reject(e);
+            clearTimeout(this.timer);
+        };
     });
-}
+}

package/src/util/disposable.ts

@@ -16,10 +16,10 @@ export interface Disposable {
 export namespace Disposable {
     export function create(func: () => void): Disposable {
         return {
-            dispose: func
+            dispose: func,
         };
     }
-    export const NULL = create(() => { });
+    export const NULL = create(() => {});
 }
 
 export class DisposableCollection implements Disposable {
@@ -69,9 +69,6 @@ export class DisposableCollection implements Disposable {
     }
 
     pushAll(disposables: Disposable[]): Disposable[] {
-        return disposables.map(disposable =>
-            this.push(disposable)
-        );
+        return disposables.map((disposable) => this.push(disposable));
     }
-
 }