@gitpod/gitpod-protocol 0.1.5-pd-ide-metrics.57 → 0.1.5-pd-ide-service.11

package/src/plans.ts

@@ -482,6 +482,10 @@ export namespace Plans {
         );
     }
 
+    export function isFreeTier(chargebeeId: string | undefined): boolean {
+        return chargebeeId === Plans.FREE.chargebeeId || chargebeeId === Plans.FREE_50.chargebeeId;
+    }
+
     export function isFreeNonTransientPlan(chargebeeId: string | undefined): boolean {
         return chargebeeId === Plans.FREE_OPEN_SOURCE.chargebeeId;
     }

package/src/protocol.ts

@@ -8,6 +8,7 @@ import { WorkspaceInstance, PortVisibility } from "./workspace-instance";
 import { RoleOrPermission } from "./permission";
 import { Project } from "./teams-projects-protocol";
 import { createHash } from "crypto";
+import { AttributionId } from "./attribution";
 
 export interface UserInfo {
     name?: string;
@@ -48,6 +49,12 @@ export interface User {
 
     // Identifies an explicit team or user ID to which all the user's workspace usage should be attributed to (e.g. for billing purposes)
     usageAttributionId?: string;
+
+    // The last time this user got verified somehow. The user is not verified if this is empty.
+    lastVerificationTime?: string;
+
+    // The phone number used for the last phone verification.
+    verificationPhoneNumber?: string;
 }
 
 export namespace User {
@@ -207,7 +214,21 @@ export interface AdditionalUserData {
     // additional user profile data
     profile?: ProfileDetails;
 }
-
+export namespace AdditionalUserData {
+    export function set(user: User, partialData: Partial<AdditionalUserData>): User {
+        if (!user.additionalData) {
+            user.additionalData = {
+                ...partialData,
+            };
+        } else {
+            user.additionalData = {
+                ...user.additionalData,
+                ...partialData,
+            };
+        }
+        return user;
+    }
+}
 // The format in which we store User Profiles in
 export interface ProfileDetails {
     // when was the last time the user updated their profile information or has been nudged to do so.
@@ -273,6 +294,8 @@ export const WorkspaceFeatureFlags = {
     full_workspace_backup: undefined,
     persistent_volume_claim: undefined,
     protected_secrets: undefined,
+    workspace_class_limiting: undefined,
+    workspace_connection_limiting: undefined,
 };
 export type NamedWorkspaceFeatureFlag = keyof typeof WorkspaceFeatureFlags;
 
@@ -781,6 +804,12 @@ export interface RepositoryCloneInformation {
     checkoutLocation?: string;
 }
 
+export interface CoreDumpConfig {
+    enabled?: boolean;
+	softLimit?: number;
+	hardLimit?: number;
+}
+
 export interface WorkspaceConfig {
     mainConfiguration?: string;
     additionalRepositories?: RepositoryCloneInformation[];
@@ -793,6 +822,7 @@ export interface WorkspaceConfig {
     github?: GithubAppConfig;
     vscode?: VSCodeConfig;
     jetbrains?: JetBrainsConfig;
+    coreDump?: CoreDumpConfig;
 
     /** deprecated. Enabled by default **/
     experimentalNetwork?: boolean;
@@ -801,13 +831,12 @@ export interface WorkspaceConfig {
      * Where the config object originates from.
      *
      * repo - from the repository
-     * project-db - from the "Project" stored in the database
      * definitly-gp - from github.com/gitpod-io/definitely-gp
      * derived - computed based on analyzing the repository
      * additional-content - config comes from additional content, usually provided through the project's configuration
      * default - our static catch-all default config
      */
-    _origin?: "repo" | "project-db" | "definitely-gp" | "derived" | "additional-content" | "default";
+    _origin?: "repo" | "definitely-gp" | "derived" | "additional-content" | "default";
 
     /**
      * Set of automatically infered feature flags. That's not something the user can set, but
@@ -1482,10 +1511,12 @@ export interface Terms {
     readonly formElements?: object;
 }
 
+export type BillingStrategy = "other" | "stripe";
 export interface CostCenter {
-    readonly id: string;
+    readonly id: AttributionId;
     /**
      * Unit: credits
      */
     spendingLimit: number;
+    billingStrategy: BillingStrategy;
 }

package/src/teams-projects-protocol.ts

@@ -27,7 +27,6 @@ export interface Project {
     teamId?: string;
     userId?: string;
     appInstallationId: string;
-    config?: ProjectConfig;
     settings?: ProjectSettings;
     creationTime: string;
     /** This is a flag that triggers the HARD DELETION of this entity */

package/src/usage.ts

@@ -6,45 +6,67 @@
 
 import { WorkspaceType } from "./protocol";
 
-export interface BillableSession {
-    // The id of the one paying the bill
+// types below are copied over from components/usage-api/typescript/src/usage/v1/usage_pb.d.ts
+export interface ListUsageRequest {
     attributionId: string;
+    from?: number;
+    to?: number;
+    order: Ordering;
+    pagination?: PaginationRequest;
+}
 
-    // 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;
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
 
-    // When the workspace ended. Not set when the workspace is still running.
-    endTime?: string;
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
 
-    // The credits used for this session
-    credits: number;
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditBalanceAtStart: number;
+    creditBalanceAtEnd: number;
+}
 
-    // TODO - maybe
-    projectId?: string;
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
 }
 
-export interface BillableSessionRequest {
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
     attributionId: string;
-    startedTimeOrder: SortOrder;
-    from?: number;
-    to?: number;
+    description: string;
+    credits: number;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
 }
 
-export type BillableWorkspaceType = WorkspaceType;
+// the equivalent golang shape is maintained in `/workspace/gitpod/`components/usage/pkg/db/usage.go`
+export interface WorkspaceInstanceUsageData {
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+    workspaceClass: string;
+    contextURL: string;
+    startTime: string;
+    endTime?: string;
+    userId: string;
+    userName: string;
+    userAvatarURL: string;
+}
 
-export enum SortOrder {
-    Descending = 0,
-    Ascending = 1,
+export interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
 }

package/src/util/garbage-collected-cache.ts

@@ -37,6 +37,11 @@ export class GarbageCollectedCache<T> {
         if (!entry) {
             return undefined;
         }
+        // Still valid?
+        if (entry.expiryDate < Date.now()) {
+            this.store.delete(entry.key);
+            return undefined;
+        }
         return entry.value;
     }
 

package/src/util/logging.spec.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { suite, test } from "mocha-typescript";
+import { log } from "./logging";
+
+@suite
+class TestLogging {
+    @test public async testLogInfo_output() {
+        const testObj = {
+            null: null,
+            undefined: undefined,
+            empty: "",
+            foo: "bar",
+            number: 0,
+        };
+        log.info("info logging test", testObj);
+    }
+}
+module.exports = new TestLogging();

package/src/util/nice-grpc.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { isAbortError } from "abort-controller-x";
+import {
+    CallOptions,
+    ClientError,
+    ClientMiddleware,
+    ClientMiddlewareCall,
+    Status,
+    MethodDescriptor,
+} from "nice-grpc-common";
+import { GrpcMethodType, IClientCallMetrics } from "./grpc";
+
+function getLabels(method: MethodDescriptor) {
+    const callType = method.requestStream
+        ? method.responseStream
+            ? "bidi_stream"
+            : "client_stream"
+        : method.responseStream
+        ? "server_stream"
+        : "unary";
+    const { path } = method;
+    const [serviceName, methodName] = path.split("/").slice(1);
+
+    return {
+        type: callType as GrpcMethodType,
+        service: serviceName,
+        method: methodName,
+    };
+}
+
+async function* incrementStreamMessagesCounter<T>(iterable: AsyncIterable<T>, callback: () => void): AsyncIterable<T> {
+    for await (const item of iterable) {
+        callback();
+        yield item;
+    }
+}
+
+export function prometheusClientMiddleware(metrics: IClientCallMetrics): ClientMiddleware {
+    return async function* prometheusClientMiddlewareGenerator<Request, Response>(
+        call: ClientMiddlewareCall<Request, Response>,
+        options: CallOptions,
+    ): AsyncGenerator<Response, Response | void, undefined> {
+        const labels = getLabels(call.method);
+
+        metrics.started(labels);
+
+        let settled = false;
+        let status: Status = Status.OK;
+
+        try {
+            let request;
+
+            if (!call.requestStream) {
+                request = call.request;
+            } else {
+                request = incrementStreamMessagesCounter(call.request, metrics.sent.bind(metrics, labels));
+            }
+
+            if (!call.responseStream) {
+                const response = yield* call.next(request, options);
+                settled = true;
+                return response;
+            } else {
+                yield* incrementStreamMessagesCounter(
+                    call.next(request, options),
+                    metrics.received.bind(metrics, labels),
+                );
+                settled = true;
+                return;
+            }
+        } catch (err) {
+            settled = true;
+            if (err instanceof ClientError) {
+                status = err.code;
+            } else if (isAbortError(err)) {
+                status = Status.CANCELLED;
+            } else {
+                status = Status.UNKNOWN;
+            }
+            throw err;
+        } finally {
+            if (!settled) {
+                status = Status.CANCELLED;
+            }
+            metrics.handled({ ...labels, code: Status[status] });
+        }
+    };
+}

package/src/util/timeutil.spec.ts

@@ -7,10 +7,16 @@
 import * as chai from "chai";
 const expect = chai.expect;
 import { suite, test } from "mocha-typescript";
-import { oneMonthLater } from "./timeutil";
+import { daysBefore, hoursBefore, oneMonthLater } from "./timeutil";
 
 @suite()
 export class TimeutilSpec {
+    @test
+    testDaysBefore() {
+        const now = new Date().toISOString();
+        expect(daysBefore(now, 2)).to.be.eq(hoursBefore(now, 48));
+    }
+
     @test
     testTimeutil() {
         // targeting a 1st, 1th of Jan => 1st of Feb
@@ -39,4 +45,25 @@ export class TimeutilSpec {
         const later = oneMonthLater(from.toISOString(), day);
         expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString());
     }
+
+    @test
+    testDaysBefore2() {
+        const tests: { date: Date; daysEarlier: number; expectation: string }[] = [
+            {
+                date: new Date("2021-07-13T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2020-07-13T00:00:00.000Z",
+            },
+            {
+                date: new Date("2019-02-01T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2018-02-01T00:00:00.000Z",
+            },
+        ];
+
+        for (const t of tests) {
+            const actual = daysBefore(t.date.toISOString(), t.daysEarlier);
+            expect(actual).to.equal(t.expectation, `expected ${actual} to be equal ${t.expectation}`);
+        }
+    }
 }

package/src/util/timeutil.ts

@@ -47,6 +47,12 @@ export const orderAsc = (d1: string, d2: string): number => liftDate(d1, d2, (d1
 export const liftDate1 = <T>(d1: string, f: (d1: Date) => T): T => f(new Date(d1));
 export const liftDate = <T>(d1: string, d2: string, f: (d1: Date, d2: Date) => T): T => f(new Date(d1), new Date(d2));
 
+export function daysBefore(date: string, days: number): string {
+    const result = new Date(date);
+    result.setDate(result.getDate() - days);
+    return result.toISOString();
+}
+
 export function hoursBefore(date: string, hours: number): string {
     const result = new Date(date);
     result.setHours(result.getHours() - hours);

package/src/workspace-class.ts

@@ -10,5 +10,5 @@ export interface SupportedWorkspaceClass {
     displayName: string;
     description: string;
     powerups: number;
-    isDefault: boolean;
+    isSelected: boolean;
 }

package/src/workspace-instance.ts

@@ -246,6 +246,9 @@ export interface WorkspaceInstanceConfiguration {
     // 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;