@oneuptime/common 11.0.1 → 11.0.3

package/Server/Utils/Telemetry/ResourceFacetResolver.ts

@@ -5,6 +5,7 @@ import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
 import ServiceModel from "../../../Models/DatabaseModels/Service";
 import HostModel from "../../../Models/DatabaseModels/Host";
 import DockerHostModel from "../../../Models/DatabaseModels/DockerHost";
+import PodmanHostModel from "../../../Models/DatabaseModels/PodmanHost";
 import KubernetesClusterModel from "../../../Models/DatabaseModels/KubernetesCluster";
 import ServerlessFunctionModel from "../../../Models/DatabaseModels/ServerlessFunction";
 import CloudResourceModel from "../../../Models/DatabaseModels/CloudResource";
@@ -12,6 +13,7 @@ import RumApplicationModel from "../../../Models/DatabaseModels/RumApplication";
 import ServiceService from "../../Services/ServiceService";
 import HostService from "../../Services/HostService";
 import DockerHostService from "../../Services/DockerHostService";
+import PodmanHostService from "../../Services/PodmanHostService";
 import KubernetesClusterService from "../../Services/KubernetesClusterService";
 import ServerlessFunctionService from "../../Services/ServerlessFunctionService";
 import CloudResourceService from "../../Services/CloudResourceService";
@@ -34,6 +36,7 @@ export const RESOURCE_FACET_KEYS: ReadonlySet<string> = new Set([
   "serviceId",
   "hostId",
   "dockerHostId",
+  "podmanHostId",
   "kubernetesClusterId",
   "serverlessFunctionId",
   "cloudResourceId",
@@ -118,6 +121,13 @@ export default class ResourceFacetResolver {
           searchText,
           limit,
         );
+      case "podmanHostId":
+        return ResourceFacetResolver.queryPodmanHosts(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
       case "kubernetesClusterId":
         return ResourceFacetResolver.queryKubernetesClusters(
           projectId,
@@ -260,6 +270,45 @@ export default class ResourceFacetResolver {
     );
   }
 
+  private static async queryPodmanHosts(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new MultiSearch({
+        fields: ["name", "hostIdentifier"],
+        value: searchText,
+      });
+    }
+
+    const podmanHosts: Array<PodmanHostModel> = await PodmanHostService.findBy({
+      query: query as any,
+      select: {
+        _id: true,
+        name: true,
+        hostIdentifier: true,
+      },
+      limit: new PositiveNumber(limit),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return ResourceFacetResolver.mergeCounts(
+      podmanHosts.map(
+        (p: PodmanHostModel): { id: string; displayName: string } => {
+          return {
+            id: p._id ? p._id.toString() : "",
+            displayName: p.name || p.hostIdentifier || "Unknown",
+          };
+        },
+      ),
+      counts,
+    );
+  }
+
   private static async queryKubernetesClusters(
     projectId: ObjectID,
     counts: Map<string, number>,

package/Server/Utils/Telemetry/Telemetry.ts

@@ -163,6 +163,16 @@ export default class TelemetryUtil {
     };
   }
 
+  public static getAttributesForPodmanHostIdAndHostName(data: {
+    podmanHostId: ObjectID;
+    hostName: string;
+  }): Dictionary<AttributeType> {
+    return {
+      "oneuptime.podman.host.id": data.podmanHostId.toString(),
+      "oneuptime.podman.host.name": data.hostName,
+    };
+  }
+
   public static getAttributesForKubernetesClusterIdAndName(data: {
     kubernetesClusterId: ObjectID;
     clusterName: string;

package/Server/Utils/Telemetry/TelemetryEntity.ts

@@ -533,6 +533,92 @@ export default class TelemetryEntity {
       return { entityType: EntityType.KubernetesDeployment, id };
     },
 
+    // proxmox.cluster — proxmox.cluster.name only (see proxmoxClusterIdentity).
+    (attrs: EntityAttributes) => {
+      const id: Dictionary<string> | null =
+        TelemetryEntity.proxmoxClusterIdentity(attrs);
+      return id ? { entityType: EntityType.ProxmoxCluster, id } : null;
+    },
+
+    // proxmox.node — cluster + proxmox.node.name.
+    (attrs: EntityAttributes) => {
+      const nodeName: string | null = TelemetryEntity.str(
+        attrs,
+        "proxmox.node.name",
+      );
+      if (!nodeName) {
+        return null;
+      }
+      const id: Dictionary<string> = {
+        ...(TelemetryEntity.proxmoxClusterIdentity(attrs) || {}),
+        "proxmox.node.name": nodeName,
+      };
+      return { entityType: EntityType.ProxmoxNode, id };
+    },
+
+    /*
+     * proxmox.guest — cluster + proxmox.guest.vmid. The node name is
+     * deliberately NOT part of guest identity: vmids are cluster-unique
+     * and a live migration moves a guest between nodes without changing
+     * what it is, so folding the node in would fork the key on every
+     * migration. Guest name/type are descriptive (a guest can be renamed).
+     */
+    (attrs: EntityAttributes) => {
+      const vmid: string | null = TelemetryEntity.str(
+        attrs,
+        "proxmox.guest.vmid",
+      );
+      if (!vmid) {
+        return null;
+      }
+      const id: Dictionary<string> = {
+        ...(TelemetryEntity.proxmoxClusterIdentity(attrs) || {}),
+        "proxmox.guest.vmid": vmid,
+      };
+      return { entityType: EntityType.ProxmoxGuest, id };
+    },
+
+    /*
+     * ceph.cluster — ceph.cluster.name only. `ceph.cluster.fsid` is
+     * descriptive, not identity: the typed Postgres row (CephCluster) and
+     * the read side (`EntityKey.keyForCephCluster`) are name-based, and
+     * the fsid is only optionally stamped by the agent.
+     */
+    (attrs: EntityAttributes) => {
+      const name: string | null = TelemetryEntity.str(
+        attrs,
+        "ceph.cluster.name",
+      );
+      return name
+        ? {
+            entityType: EntityType.CephCluster,
+            id: { "ceph.cluster.name": name },
+          }
+        : null;
+    },
+
+    /*
+     * docker.swarm.cluster — docker.swarm.cluster.name only, mirroring the
+     * proxmox/ceph cluster identity: the typed Postgres row
+     * (DockerSwarmCluster) and the read side
+     * (`EntityKey.keyForDockerSwarmCluster`) are name-based, and the agent
+     * stamps `docker.swarm.cluster.name` on every signal. Node/Service/Task
+     * identity is NOT derived from resource attributes (inventory arrives as
+     * separate JSON-line log records), so only the cluster entity flows here.
+     */
+    (attrs: EntityAttributes) => {
+      const name: string | null = TelemetryEntity.str(
+        attrs,
+        "docker.swarm.cluster.name",
+      );
+      return name
+        ? {
+            entityType: EntityType.DockerSwarmCluster,
+            id: { "docker.swarm.cluster.name": name },
+          }
+        : null;
+    },
+
     /*
      * container — container.id. High-churn: flows as a membership key but
      * is membership-only by default (not promoted to a registry row
@@ -652,6 +738,8 @@ export default class TelemetryEntity {
       "container.image.tag",
       "container.image.tags",
     ],
+    [EntityType.ProxmoxGuest]: ["proxmox.guest.name", "proxmox.guest.type"],
+    [EntityType.CephCluster]: ["ceph.cluster.fsid"],
   };
 
   private static descriptiveAttributesFor(
@@ -739,6 +827,25 @@ export default class TelemetryEntity {
     return null;
   }
 
+  /*
+   * Proxmox cluster identity — proxmox.cluster.name only, mirroring
+   * k8sClusterIdentity above: the typed Postgres row (ProxmoxCluster) and
+   * the read side (`EntityKey.keyForProxmoxCluster`) are name-based, and
+   * the attribute is the user-configured join key our agent stamps on
+   * every resource (see Internal/Roadmap/ProxmoxCephProducts.md §1). This
+   * identity is also folded into the composite proxmox node/guest
+   * identities, which must stay name-based with it.
+   */
+  private static proxmoxClusterIdentity(
+    attrs: EntityAttributes,
+  ): Dictionary<string> | null {
+    const name: string | null = this.str(attrs, "proxmox.cluster.name");
+    if (name) {
+      return { "proxmox.cluster.name": name };
+    }
+    return null;
+  }
+
   /** Copy `key` from attrs into `id` (canonicalized) when scalar & present. */
   private static addIfPresent(
     id: Dictionary<string>,

package/Server/Utils/Telemetry.ts

@@ -24,16 +24,14 @@ import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { AWSXRayIdGenerator } from "@opentelemetry/id-generator-aws-xray";
 import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { Resource } from "@opentelemetry/resources";
+import { Resource, resourceFromAttributes } from "@opentelemetry/resources";
 import {
   BatchLogRecordProcessor,
   LoggerProvider,
   LogRecordProcessor,
   type LoggerProviderConfig,
 } from "@opentelemetry/sdk-logs";
-import type { Resource as LogsResource } from "@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/Resource";
 import {
-  Aggregation,
   MeterProvider,
   PeriodicExportingMetricReader,
 } from "@opentelemetry/sdk-metrics";
@@ -56,7 +54,7 @@ import GracefulShutdown, { ShutdownPriority } from "./GracefulShutdown";
 import ContextSpanProcessor from "./Telemetry/ContextSpanProcessor";
 import RuntimeMetrics from "./Telemetry/RuntimeMetrics";
 
-type ResourceWithRawAttributes = LogsResource & {
+type ResourceWithRawAttributes = Resource & {
   getRawAttributes?: () => Array<[string, AttributeValue | undefined]>;
 };
 
@@ -165,7 +163,7 @@ export default class Telemetry {
   }
 
   public static getResource(data: { serviceName: string }): Resource {
-    return new Resource({
+    return resourceFromAttributes({
       [ATTR_SERVICE_NAME]: data.serviceName,
       [ATTR_SERVICE_VERSION]: AppVersion,
       ["deployment.environment"]: Env,
@@ -203,20 +201,11 @@ export default class Telemetry {
           compression: CompressionAlgorithm.GZIP,
         }) as unknown as PushMetricExporter;
 
-        // Force an SDK-side aggregation selector that matches the modern metrics API.
-        if (
-          typeof (metricExporter as { selectAggregation?: unknown })
-            .selectAggregation === "function"
-        ) {
-          (
-            metricExporter as unknown as {
-              selectAggregation: (..._args: Array<unknown>) => Aggregation;
-            }
-          ).selectAggregation = () => {
-            return Aggregation.Default();
-          };
-        }
-
+        /*
+         * No aggregation-selector shim is needed anymore: the OTLP metric
+         * exporter and the sdk-metrics package now come from the same release
+         * line, so the exporter's default selector already matches the SDK.
+         */
         this.metricReader = new PeriodicExportingMetricReader({
           exporter: metricExporter,
         });

package/Tests/Server/API/BillingInvoiceAPI.test.ts

@@ -0,0 +1,194 @@
+import BillingInvoiceAPI from "../../../Server/API/BillingInvoiceAPI";
+import BillingInvoiceService from "../../../Server/Services/BillingInvoiceService";
+import BillingService from "../../../Server/Services/BillingService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import {
+  NextFunction,
+  OneUptimeRequest,
+  OneUptimeResponse,
+} from "../../../Server/Utils/Express";
+import Response from "../../../Server/Utils/Response";
+import { mockRouter } from "./Helpers";
+import { describe, expect, it } from "@jest/globals";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import Permission, { UserPermission } from "../../../Types/Permission";
+import BillingInvoice from "../../../Models/DatabaseModels/BillingInvoice";
+import Project from "../../../Models/DatabaseModels/Project";
+
+jest.mock("../../../Server/Utils/Express", () => {
+  return {
+    getRouter: () => {
+      return mockRouter;
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/Response", () => {
+  return {
+    sendEntityArrayResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendJsonObjectResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendEmptySuccessResponse: jest.fn(),
+    sendEntityResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendErrorResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+  };
+});
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  return {
+    ...jest.requireActual("../../../Server/EnvironmentConfig"),
+    IsBillingEnabled: true,
+  };
+});
+
+jest.mock("../../../Server/Services/BillingInvoiceService");
+jest.mock("../../../Server/Services/BillingService");
+jest.mock("../../../Server/Services/ProjectService");
+
+describe("BillingInvoiceAPI", () => {
+  let mockRequest: OneUptimeRequest;
+  let mockResponse: OneUptimeResponse;
+  let nextFunction: NextFunction;
+
+  const projectId: ObjectID = ObjectID.generate();
+  const projectCustomerId: string = "cus_own_project";
+  const invoiceId: string = "in_123";
+
+  let project: Project;
+
+  beforeEach(() => {
+    new BillingInvoiceAPI();
+
+    project = new Project();
+    project.id = projectId;
+    project.paymentProviderCustomerId = projectCustomerId;
+    project.paymentProviderSubscriptionId = "sub_123";
+
+    jest
+      .spyOn(BillingInvoiceAPI.prototype, "getPermissionsForTenant")
+      .mockResolvedValue([
+        {
+          permission: Permission.EditInvoices,
+        } as UserPermission,
+      ]);
+
+    ProjectService.findOneById = jest.fn().mockResolvedValue(project);
+    BillingInvoiceService.findOneBy = jest
+      .fn()
+      .mockResolvedValue(new BillingInvoice());
+    BillingInvoiceService.updateOneBy = jest.fn().mockResolvedValue(undefined);
+    BillingInvoiceService.refreshSubscriptionStatus = jest
+      .fn()
+      .mockResolvedValue(undefined);
+    BillingService.payInvoice = jest.fn().mockResolvedValue({
+      id: invoiceId,
+      status: "paid",
+    });
+
+    mockRequest = {
+      tenantId: projectId,
+      body: {
+        data: {
+          paymentProviderInvoiceId: invoiceId,
+          paymentProviderCustomerId: projectCustomerId,
+        },
+      },
+    } as unknown as OneUptimeRequest;
+    mockResponse = {
+      send: jest.fn(),
+      json: jest.fn(),
+      status: jest.fn().mockReturnThis(),
+    } as unknown as OneUptimeResponse;
+    nextFunction = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("POST /billing-invoices/pay", () => {
+    it("should reject a customer id that does not belong to the project", async () => {
+      mockRequest.body["data"] = {
+        paymentProviderInvoiceId: invoiceId,
+        paymentProviderCustomerId: "cus_victim_tenant",
+      };
+
+      await mockRouter
+        .match("post", "/billing-invoices/pay")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).toHaveBeenCalledWith(
+        new BadDataException("Customer ID does not belong to this project"),
+      );
+      expect(BillingService.payInvoice).not.toHaveBeenCalled();
+      expect(BillingInvoiceService.updateOneBy).not.toHaveBeenCalled();
+    });
+
+    it("should reject an invoice that does not belong to the project", async () => {
+      BillingInvoiceService.findOneBy = jest.fn().mockResolvedValue(null);
+
+      await mockRouter
+        .match("post", "/billing-invoices/pay")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(BillingInvoiceService.findOneBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            projectId: projectId,
+            paymentProviderInvoiceId: invoiceId,
+          },
+          /*
+           * ignoreHooks is required: BillingInvoiceService.onBeforeFind
+           * throws without props.tenantId and would re-sync all invoices
+           * from Stripe on every pay attempt.
+           */
+          props: expect.objectContaining({
+            ignoreHooks: true,
+          }),
+        }),
+      );
+      expect(nextFunction).toHaveBeenCalledWith(
+        new BadDataException("Invoice not found for this project"),
+      );
+      expect(BillingService.payInvoice).not.toHaveBeenCalled();
+      expect(BillingInvoiceService.updateOneBy).not.toHaveBeenCalled();
+    });
+
+    it("should pay with the project's own customer id and scope the status update to the project", async () => {
+      // body omits the customer id — the project's own customer is charged.
+      mockRequest.body["data"] = {
+        paymentProviderInvoiceId: invoiceId,
+      };
+
+      await mockRouter
+        .match("post", "/billing-invoices/pay")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).not.toHaveBeenCalled();
+      expect(BillingService.payInvoice).toHaveBeenCalledWith(
+        projectCustomerId,
+        invoiceId,
+      );
+      expect(BillingInvoiceService.updateOneBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            projectId: projectId,
+            paymentProviderInvoiceId: invoiceId,
+          },
+        }),
+      );
+      expect(Response.sendEmptySuccessResponse).toHaveBeenCalledWith(
+        mockRequest,
+        mockResponse,
+      );
+    });
+  });
+});

package/Tests/Server/API/ProjectAPI.test.ts

@@ -1,4 +1,6 @@
 import ProjectAPI from "../../../Server/API/ProjectAPI";
+import BillingService from "../../../Server/Services/BillingService";
+import ProjectService from "../../../Server/Services/ProjectService";
 import TeamMemberService from "../../../Server/Services/TeamMemberService";
 import {
   NextFunction,
@@ -15,6 +17,17 @@ import ObjectID from "../../../Types/ObjectID";
 import PositiveNumber from "../../../Types/PositiveNumber";
 import Project from "../../../Models/DatabaseModels/Project";
 import TeamMember from "../../../Models/DatabaseModels/TeamMember";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import Permission, { UserPermission } from "../../../Types/Permission";
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  return {
+    ...jest.requireActual("../../../Server/EnvironmentConfig"),
+    IsBillingEnabled: true,
+  };
+});
+
+jest.mock("../../../Server/Services/BillingService");
 
 jest.mock("../../../Server/Utils/Express", () => {
   return {
@@ -216,4 +229,82 @@ describe("ProjectAPI", () => {
       expect(nextFunction).toHaveBeenCalledWith(authError);
     });
   });
+
+  describe("PUT /project/:id/change-plan", () => {
+    const planId: string = "plan_123";
+
+    const tenantMismatchError: BadDataException = new BadDataException(
+      "Project ID in the URL does not match the project the request is authenticated for",
+    );
+
+    beforeEach(() => {
+      ProjectService.findOneById = jest.fn().mockResolvedValue({
+        paymentProviderCustomerId: "cus_123",
+      } as Project);
+      ProjectService.changePlan = jest.fn().mockResolvedValue(undefined);
+      BillingService.hasPaymentMethods = jest.fn().mockResolvedValue(true);
+    });
+
+    it("should reject when the URL project id does not match the authenticated tenant", async () => {
+      const victimProjectId: ObjectID = ObjectID.generate();
+      const attackerProjectId: ObjectID = ObjectID.generate();
+
+      mockRequest.params = { id: victimProjectId.toString() };
+      mockRequest.tenantId = attackerProjectId;
+      mockRequest.body = { data: { paymentProviderPlanId: planId } };
+
+      await mockRouter
+        .match("put", "/project/:id/change-plan")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).toHaveBeenCalledWith(tenantMismatchError);
+      expect(ProjectService.changePlan).not.toHaveBeenCalled();
+      // the foreign project must not even be looked up.
+      expect(ProjectService.findOneById).not.toHaveBeenCalled();
+    });
+
+    it("should reject when the request has no authenticated tenant", async () => {
+      const projectId: ObjectID = ObjectID.generate();
+
+      mockRequest.params = { id: projectId.toString() };
+      mockRequest.body = { data: { paymentProviderPlanId: planId } };
+
+      await mockRouter
+        .match("put", "/project/:id/change-plan")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).toHaveBeenCalledWith(tenantMismatchError);
+      expect(ProjectService.changePlan).not.toHaveBeenCalled();
+    });
+
+    it("should change the plan of the authenticated tenant's own project", async () => {
+      const projectId: ObjectID = ObjectID.generate();
+
+      mockRequest.params = { id: projectId.toString() };
+      mockRequest.tenantId = projectId;
+      mockRequest.body = { data: { paymentProviderPlanId: planId } };
+
+      jest
+        .spyOn(ProjectAPI.prototype, "getPermissionsForTenant")
+        .mockResolvedValue([
+          {
+            permission: Permission.ProjectOwner,
+          } as UserPermission,
+        ]);
+
+      await mockRouter
+        .match("put", "/project/:id/change-plan")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).not.toHaveBeenCalled();
+      expect(ProjectService.changePlan).toHaveBeenCalledWith({
+        projectId: projectId,
+        paymentProviderPlanId: planId,
+      });
+      expect(Response.sendEmptySuccessResponse).toHaveBeenCalledWith(
+        mockRequest,
+        mockResponse,
+      );
+    });
+  });
 });