deepline 0.3.128 → 0.3.130

package/dist/bundling-sources/shared_libs/play-runtime/deployment/runtime-gateway-capacity.ts

@@ -0,0 +1,71 @@
+/**
+ * Exact-machine capacity observations for the runtime gateway fleet.
+ *
+ * The public gateway metrics endpoint is useful for dashboards, but it cannot
+ * identify which Fly Machine answered a request. Autoscaling therefore probes
+ * the private metrics port through the Machine's 6PN hostname and requires the
+ * caller to validate the exact Machine identity header before using a sample.
+ */
+import type { FlyMachine } from './fly-machine-lifecycle';
+
+export const GATEWAY_UPSTREAM_IN_FLIGHT_METRIC =
+  'deepline_runtime_gateway_upstream_admission_in_flight';
+export const GATEWAY_UPSTREAM_WAITING_METRIC =
+  'deepline_runtime_gateway_upstream_admission_waiting';
+
+export type RuntimeGatewayCapacity = {
+  inFlight: number;
+  waiting: number;
+};
+
+export type RuntimeGatewayCapacitySnapshot = RuntimeGatewayCapacity & {
+  machineId: string;
+};
+
+function parseGauge(metrics: string, metricName: string): number {
+  const match = metrics.match(
+    new RegExp(
+      `^${metricName}(?:\\{[^\\n]*\\})?\\s+([0-9]+(?:\\.[0-9]+)?)\\s*$`,
+      'm',
+    ),
+  );
+  if (!match) {
+    throw new Error(
+      `Gateway capacity proof is missing ${metricName}; refusing to scale from an incomplete Machine sample.`,
+    );
+  }
+  const value = Number(match[1]);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(
+      `Gateway capacity proof reported an invalid ${metricName} value.`,
+    );
+  }
+  return value;
+}
+
+export function parseGatewayCapacityMetrics(
+  metrics: string,
+): RuntimeGatewayCapacity {
+  return {
+    inFlight: parseGauge(metrics, GATEWAY_UPSTREAM_IN_FLIGHT_METRIC),
+    waiting: parseGauge(metrics, GATEWAY_UPSTREAM_WAITING_METRIC),
+  };
+}
+
+export function aggregateGatewayCapacity(
+  observations: readonly RuntimeGatewayCapacitySnapshot[],
+): RuntimeGatewayCapacity {
+  return observations.reduce(
+    (total, observation) => ({
+      inFlight: total.inFlight + observation.inFlight,
+      waiting: total.waiting + observation.waiting,
+    }),
+    { inFlight: 0, waiting: 0 },
+  );
+}
+
+export function machineIsServingRuntimeGateway(
+  machine: Pick<FlyMachine, 'state' | 'cordoned'>,
+): boolean {
+  return machine.state === 'started' && machine.cordoned === false;
+}

package/dist/bundling-sources/shared_libs/play-runtime/deployment/runtime-gateway-drain.ts

@@ -59,7 +59,7 @@ function isRetryablePrivateMetricsProbeError(error: unknown): boolean {
   );
 }
 
-async function readPrivateGatewayMetrics(input: {
+export async function readPrivateGatewayMetrics(input: {
   app: string;
   machineId: string;
   fetchImpl: typeof fetch;

package/dist/bundling-sources/shared_libs/play-runtime/deployment/runtime-topology.ts

@@ -8,6 +8,9 @@
  */
 export type RuntimeGatewayRole = 'receipt' | 'execution';
 export type RuntimeGatewayTopologyProfile = 'production' | 'preview';
+/** Durable marker for capacity Machines owned by the execution relay scaler. */
+export const RUNTIME_GATEWAY_AUTOSCALED_METADATA_KEY =
+  'deepline_gateway_autoscaled';
 
 export type RuntimeGatewayMachineConfig = {
   env: Record<string, string>;
@@ -58,7 +61,7 @@ const httpService = (minimumMachines: number): Record<string, unknown> => ({
       path: '/healthz',
     },
   ],
-  concurrency: { type: 'requests', soft_limit: 1, hard_limit: 64 },
+  concurrency: { type: 'requests', soft_limit: 128, hard_limit: 1024 },
 });
 
 function gatewayMachine(