fix(js-sdk): pass getMetrics start/end as query params (#1427)

## Description

`Sandbox.getMetrics()` in the JS SDK passed the `start` and `end`
options as path parameters instead of query parameters, so openapi-fetch
never serialized them and the requested time range was silently ignored.
They are now sent under `query`, matching the OpenAPI spec; the Python
SDKs already passed them correctly. The metrics tests across JS and
Python (sync/async) now assert that returned metrics fall within the
requested window (with slack for 5s metric-bucket alignment) and that a
window from before the sandbox existed returns no metrics, which would
have caught this regression.

## Usage

```ts
const start = new Date(Date.now() - 60_000)
const metrics = await sandbox.getMetrics({ start, end: new Date() })
// metrics are now actually limited to the requested time range
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: mishushakov

.changeset/brave-pandas-listen.md

@@ -0,0 +1,5 @@
+---
+"e2b": patch
+---
+
+Fix `Sandbox.getMetrics()` sending `start` and `end` as path parameters instead of query parameters, which caused the requested time range to be silently ignored

packages/js-sdk/src/sandbox/sandboxApi.ts

@@ -798,6 +798,8 @@ export class SandboxApi {
       params: {
         path: {
           sandboxID: sandboxId,
+        },
+        query: {
           start,
           end,
         },

packages/js-sdk/tests/sandbox/metrics.test.ts

@@ -7,8 +7,8 @@ sandboxTest.skipIf(isDebug)(
   'sbx metrics',
   { timeout: 60_000 },
   async ({ sandbox }) => {
-    const now = new Date()
-    let metrics: SandboxMetrics[]
+    // Wait for the sandbox to have some metrics
+    let metrics: SandboxMetrics[] = []
     for (let i = 0; i < 60; i++) {
       metrics = await sandbox.getMetrics()
       if (metrics.length > 0) {
@@ -25,8 +25,45 @@ sandboxTest.skipIf(isDebug)(
     expect(metric.memUsed).toBeDefined()
     expect(metric.cpuUsedPct).toBeDefined()
     expect(metric.cpuCount).toBeDefined()
+  }
+)
+
+sandboxTest.skipIf(isDebug)(
+  'sbx metrics time range',
+  { timeout: 60_000 },
+  async ({ sandbox }) => {
+    const start = new Date()
+
+    // Wait for the sandbox to have some metrics within the test's time window
+    let metrics: SandboxMetrics[] = []
+    let end = new Date()
+    for (let i = 0; i < 60; i++) {
+      end = new Date()
+      metrics = await sandbox.getMetrics({ start, end })
+      if (metrics.length > 0) {
+        break
+      }
+      await wait(500)
+    }
 
-    metrics = await sandbox.getMetrics({ start: now, end: new Date() })
     expect(metrics.length).toBeGreaterThan(0)
+
+    // All returned metrics must fall within the requested time range
+    // (10s slack — metric timestamps are aligned to collection buckets,
+    // currently 5s, and the query params are second-precision)
+    const slackMs = 10_000
+    for (const m of metrics) {
+      expect(m.timestamp.getTime()).toBeGreaterThanOrEqual(
+        start.getTime() - slackMs
+      )
+      expect(m.timestamp.getTime()).toBeLessThanOrEqual(end.getTime() + slackMs)
+    }
+
+    // A time range from before the sandbox existed must return no metrics
+    const noMetrics = await sandbox.getMetrics({
+      start: new Date(start.getTime() - 60 * 60 * 1000),
+      end: new Date(start.getTime() - 30 * 60 * 1000),
+    })
+    expect(noMetrics).toHaveLength(0)
   }
 )

packages/python-sdk/tests/async/sandbox_async/test_metrics.py

@@ -7,7 +7,6 @@
 @pytest.mark.skip_debug()
 @pytest.mark.timeout(60)
 async def test_sbx_metrics(async_sandbox_factory):
-    start_time = datetime.datetime.now()
     sbx = await async_sandbox_factory(timeout=60)
 
     # Wait for the sandbox to have some metrics
@@ -28,5 +27,36 @@ async def test_sbx_metrics(async_sandbox_factory):
     assert metric.disk_used is not None
     assert metric.disk_total is not None
 
-    metrics = await sbx.get_metrics(start=start_time, end=datetime.datetime.now())
+
+@pytest.mark.skip_debug()
+@pytest.mark.timeout(60)
+async def test_sbx_metrics_time_range(async_sandbox_factory):
+    start_time = datetime.datetime.now(datetime.timezone.utc)
+    sbx = await async_sandbox_factory(timeout=60)
+
+    # Wait for the sandbox to have some metrics within the test's time window
+    metrics = []
+    end_time = start_time
+    for _ in range(60):
+        end_time = datetime.datetime.now(datetime.timezone.utc)
+        metrics = await sbx.get_metrics(start=start_time, end=end_time)
+        if len(metrics) > 0:
+            break
+        await asyncio.sleep(0.5)
+
     assert len(metrics) > 0
+
+    # All returned metrics must fall within the requested time range
+    # (10s slack - metric timestamps are aligned to collection buckets,
+    # currently 5s, and the query params are second-precision)
+    slack = 10
+    for metric in metrics:
+        assert metric.timestamp.timestamp() >= start_time.timestamp() - slack
+        assert metric.timestamp.timestamp() <= end_time.timestamp() + slack
+
+    # A time range from before the sandbox existed must return no metrics
+    metrics = await sbx.get_metrics(
+        start=start_time - datetime.timedelta(hours=1),
+        end=start_time - datetime.timedelta(minutes=30),
+    )
+    assert len(metrics) == 0

packages/python-sdk/tests/sync/sandbox_sync/test_metrics.py

@@ -7,8 +7,8 @@
 @pytest.mark.skip_debug()
 @pytest.mark.timeout(60)
 def test_sbx_metrics(sandbox_factory) -> None:
-    start_time = datetime.datetime.now()
     sbx = sandbox_factory(timeout=60)
+
     # Wait for the sandbox to have some metrics
     metrics = []
     for _ in range(60):
@@ -27,5 +27,36 @@ def test_sbx_metrics(sandbox_factory) -> None:
     assert metric.disk_used is not None
     assert metric.disk_total is not None
 
-    metrics = sbx.get_metrics(start=start_time, end=datetime.datetime.now())
+
+@pytest.mark.skip_debug()
+@pytest.mark.timeout(60)
+def test_sbx_metrics_time_range(sandbox_factory) -> None:
+    start_time = datetime.datetime.now(datetime.timezone.utc)
+    sbx = sandbox_factory(timeout=60)
+
+    # Wait for the sandbox to have some metrics within the test's time window
+    metrics = []
+    end_time = start_time
+    for _ in range(60):
+        end_time = datetime.datetime.now(datetime.timezone.utc)
+        metrics = sbx.get_metrics(start=start_time, end=end_time)
+        if len(metrics) > 0:
+            break
+        time.sleep(0.5)
+
     assert len(metrics) > 0
+
+    # All returned metrics must fall within the requested time range
+    # (10s slack - metric timestamps are aligned to collection buckets,
+    # currently 5s, and the query params are second-precision)
+    slack = 10
+    for metric in metrics:
+        assert metric.timestamp.timestamp() >= start_time.timestamp() - slack
+        assert metric.timestamp.timestamp() <= end_time.timestamp() + slack
+
+    # A time range from before the sandbox existed must return no metrics
+    metrics = sbx.get_metrics(
+        start=start_time - datetime.timedelta(hours=1),
+        end=start_time - datetime.timedelta(minutes=30),
+    )
+    assert len(metrics) == 0