Add metrics methods to SDKs

Makefile

@@ -11,6 +11,7 @@ generate-js:
 	cd packages/js-sdk && pnpm generate-envd-api
 	cd spec/envd && buf generate --template buf-js.gen.yaml
 
+# `brew install protobuf` beforehand
 generate-python:
 	$(MAKE) -C packages/connect-python build
 	cd packages/python-sdk && make generate-api

apps/web/src/app/(docs)/docs/sandbox/list/page.mdx

@@ -1,3 +1,5 @@
+import Link from 'next/link'
+
 # List running sandboxes
 
 You can list all running sandboxes using the `Sandbox.list()` method.
@@ -58,3 +60,51 @@ Running sandbox started at: 2024-10-15 21:13:07.311861+00:00
 Running sandbox template id: 3e4rngfa34txe0gxc1zf
 ```
 </CodeGroup>
+
+
+## Filtering sandboxes
+<Note>
+This feature is in a private beta.
+</Note>
+
+You can filter sandboxes by specifying <Link href="/docs/sandbox/metadata">Metadata</Link> key value pairs.
+Specifying multiple key value pairs will return sandboxes that match all of them.
+
+This can be useful when you have a large number of sandboxes and want to find only specific ones. The filtering is performed on the server.
+
+<CodeGroup>
+```js
+import { Sandbox } from '@e2b/code-interpreter'
+
+// Create sandbox with metadata.
+const sandbox = await Sandbox.create({
+  metadata: {
+    env: 'dev', // $HighlightLine
+    app: 'my-app', // $HighlightLine
+    userId: '123', // $HighlightLine
+  },
+})
+
+// List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
+const runningSandboxes = await Sandbox.list({
+    filters: { userId: '123', env: 'dev' } // $HighlightLine
+})
+```
+```python
+from e2b_code_interpreter import Sandbox
+
+# Create sandbox with metadata.
+sandbox = Sandbox(
+    metadata={
+        "env": "dev", # $HighlightLine
+        "app": "my-app", # $HighlightLine
+        "user_id": "123", # $HighlightLine
+    },
+)
+
+# List running sandboxes that has `userId` key with value `123` and `env` key with value `dev`.
+running_sandboxes = Sandbox.list(filters={
+    "userId": "123", "env": "dev" # $HighlightLine
+})
+```
+</CodeGroup>

apps/web/src/app/(docs)/docs/sandbox/metadata/page.mdx

@@ -1,3 +1,5 @@
+import Link from 'next/link'
+
 # Sandbox metadata
 
 Metadata is a way to attach arbitrary key-value pairs for a sandbox.
@@ -47,3 +49,6 @@ running_sandboxes = Sandbox.list()
 print(running_sandboxes[0].metadata)
 ```
 </CodeGroup>
+
+## Filtering sandboxes by metadata
+You can also filter sandboxes by metadata, you can find more about it <Link href="/docs/sandbox/list#filtering-sandboxes">here</Link>.

apps/web/src/components/Pricing/SwitchToProButton.tsx

@@ -9,18 +9,9 @@ import Spinner from '@/components/Spinner'
 
 import { TierActiveTag } from './TierActiveTag'
 import { getBillingUrl } from '@/app/(dashboard)/dashboard/utils'
-import { toast } from '@/components/ui/use-toast'
 
 function createCheckout(domain: string, tierID: string, teamID: string) {
-  if (domain !== 'e2b.dev') {
-    console.error('Managing billing is allowed only at e2b.dev.')
-    toast({
-      title: 'Error',
-      description: 'Managing billing is allowed only at e2b.dev.',
-    })
-  }
-
-  return fetch(getBillingUrl(domain, '/checkouts'), {
+  return fetch(getBillingUrl('e2b.dev', '/checkouts'), {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',

apps/web/src/utils/useUser.tsx

@@ -15,13 +15,16 @@ export type Team = {
   apiKeys: string[]
 }
 
+interface APIKey { api_key: string; }
 interface UserTeam {
-  id: string;
-  name: string;
   is_default: boolean;
-  tier: string;
-  email: string;
-  team_api_keys: { api_key: string; }[];
+  teams: {
+    tier: string;
+    email: string;
+    team_api_keys: { api_key: string; }[];
+    id: string;
+    name: string;
+  }
 }
 
 export type E2BUser = (User & {
@@ -110,20 +113,30 @@ export const CustomUserContextProvider = (props) => {
       if (!session) return
       if (!session.user.id) return
 
-      // @ts-ignore
-      const { data: userTeams, teamsError } = await supabase
+      const { data: userTeams, error: teamsError } = await supabase
         .from('users_teams')
-        .select('teams (id, name, is_default, tier, email, team_api_keys (api_key))')
+        .select('is_default, teams (id, name, tier, email, team_api_keys (api_key))')
         .eq('user_id', session?.user.id) // Due to RLS, we could also safely just fetch all, but let's be explicit for sure
 
       if (teamsError) Sentry.captureException(teamsError)
-      // TODO: Adjust when user can be part of multiple teams
-      // @ts-ignore
-      const teams = userTeams?.map(userTeam => userTeam.teams).map((team: UserTeam) => ({
-        ...team,
-        apiKeys: team.team_api_keys.map(apiKey => apiKey.api_key)
-      } as Team))
 
+      if (userTeams === undefined || userTeams === null) {
+        console.log('No user teams found')
+        Sentry.captureEvent({ message: 'No user teams found' })
+        return
+      }
+
+      const typedUserTeams = userTeams as unknown as UserTeam[]
+      const teams: Team[] = typedUserTeams.map((userTeam: UserTeam): Team => {
+        return {
+          id: userTeam.teams.id,
+          name: userTeam.teams.name,
+          tier: userTeam.teams.tier,
+          is_default: userTeam.is_default,
+          email: userTeam.teams.email,
+          apiKeys: userTeam.teams.team_api_keys.map((apiKey: APIKey) => apiKey.api_key),
+        }
+      })
       const defaultTeam = teams?.find(team => team.is_default)
 
       if (!defaultTeam) {

packages/cli/src/commands/sandbox/index.ts

@@ -1,10 +1,11 @@
 import * as commander from 'commander'
 
 import { connectCommand } from './connect'
-import { listCommand } from './list'
 import { killCommand } from './kill'
-import { spawnCommand } from './spawn'
+import { listCommand } from './list'
 import { logsCommand } from './logs'
+import { metricsCommand } from './metrics'
+import { spawnCommand } from './spawn'
 
 export const sandboxCommand = new commander.Command('sandbox')
   .description('work with sandboxes')
@@ -14,3 +15,4 @@ export const sandboxCommand = new commander.Command('sandbox')
   .addCommand(killCommand)
   .addCommand(spawnCommand)
   .addCommand(logsCommand)
+  .addCommand(metricsCommand)

packages/cli/src/commands/sandbox/logs.ts

@@ -15,7 +15,7 @@ function getShortID(sandboxID: string) {
   return sandboxID.split('-')[0]
 }
 
-function waitForSandboxEnd(sandboxID: string) {
+export function waitForSandboxEnd(sandboxID: string) {
   let isRunning = true
 
   async function monitor() {

packages/cli/src/commands/sandbox/metrics.ts

@@ -0,0 +1,199 @@
+import * as chalk from 'chalk'
+import * as commander from 'commander'
+import * as e2b from 'e2b'
+import * as util from 'util'
+
+import { client, connectionConfig } from 'src/api'
+import { asBold, asTimestamp, withUnderline } from 'src/utils/format'
+import { wait } from 'src/utils/wait'
+import { handleE2BRequestError } from '../../utils/errors'
+import { listSandboxes } from './list'
+import { waitForSandboxEnd } from './logs'
+
+const maxRuntime = 24 * 60 * 60 * 1000 // 24 hours in milliseconds
+
+function getShortID(sandboxID: string) {
+  return sandboxID.split('-')[0]
+}
+
+function formatEnum(e: { [key: string]: string }) {
+  return Object.values(e)
+    .map((level) => asBold(level))
+    .join(', ')
+}
+
+enum LogFormat {
+  JSON = 'json',
+  PRETTY = 'pretty',
+}
+
+function cleanLogger(logger?: string) {
+  if (!logger) {
+    return ''
+  }
+
+  return logger.replaceAll('Svc', '')
+}
+
+export const metricsCommand = new commander.Command('metrics')
+  .description('show metrics for sandbox')
+  .argument(
+    '<sandboxID>',
+    `show metrics for sandbox specified by ${asBold('<sandboxID>')}`
+  )
+  .alias('mt')
+  .option('-f, --follow', 'keep streaming metrics until the sandbox is closed')
+  .option(
+    '--format <format>',
+    `specify format for printing metrics (${formatEnum(LogFormat)})`,
+    LogFormat.PRETTY
+  )
+  .action(
+    async (
+      sandboxID: string,
+      opts?: {
+        level: string
+        follow: boolean
+        format: LogFormat
+        loggers?: string[]
+      }
+    ) => {
+      try {
+        const format = opts?.format.toLowerCase() as LogFormat | undefined
+        if (format && !Object.values(LogFormat).includes(format)) {
+          throw new Error(`Invalid log format: ${format}`)
+        }
+
+        const getIsRunning = opts?.follow
+          ? waitForSandboxEnd(sandboxID)
+          : () => false
+
+        let start: number | undefined
+        let isFirstRun = true
+        let firstMetricsPrinted = false
+
+        if (format === LogFormat.PRETTY) {
+          console.log(`\nMetrics for sandbox ${asBold(sandboxID)}:`)
+        }
+
+        const isRunningPromise = listSandboxes()
+          .then((r) => r.find((s) => s.sandboxID === getShortID(sandboxID)))
+          .then((s) => !!s)
+
+        do {
+          const metrics = await getSandboxMetrics({ sandboxID })
+
+          if (metrics.length !== 0 && firstMetricsPrinted === false) {
+            firstMetricsPrinted = true
+            process.stdout.write('\n')
+          }
+
+          for (const metric of metrics) {
+            printMetric(metric.timestamp, JSON.stringify(metric), format)
+          }
+
+          const isRunning = await isRunningPromise
+
+          if (!isRunning && metrics.length === 0 && isFirstRun) {
+            if (format === LogFormat.PRETTY) {
+              console.log(
+                `\nStopped printing metrics — sandbox ${withUnderline(
+                  'not found'
+                )}`
+              )
+            }
+            break
+          }
+
+          if (!isRunning) {
+            if (format === LogFormat.PRETTY) {
+              console.log(
+                `\nStopped printing metrics — sandbox is ${withUnderline(
+                  'closed'
+                )}`
+              )
+            }
+            break
+          }
+
+          const lastMetric =
+            metrics.length > 0 ? metrics[metrics.length - 1] : undefined
+          if (lastMetric) {
+            // TODO: Use the timestamp from the last metric instead of the current time?
+            start = new Date(lastMetric.timestamp).getTime() + 1
+          }
+
+          await wait(400)
+          isFirstRun = false
+        } while (getIsRunning() && opts?.follow)
+      } catch (err: any) {
+        console.error(err)
+        process.exit(1)
+      }
+    }
+  )
+
+function printMetric(
+  timestamp: string,
+  line: string,
+  format: LogFormat | undefined
+) {
+  const metric = JSON.parse(line)
+  const level = chalk.default.green()
+
+  metric.logger = cleanLogger(metric.logger)
+
+  delete metric['traceID']
+  delete metric['instanceID']
+  delete metric['source_type']
+  delete metric['teamID']
+  delete metric['source']
+  delete metric['service']
+  delete metric['envID']
+  delete metric['sandboxID']
+  delete metric['logger']
+
+  if (format === LogFormat.JSON) {
+    console.log(
+      JSON.stringify({
+        timestamp: new Date(timestamp).toISOString(),
+        level,
+        ...metric,
+      })
+    )
+  } else {
+    const time = `[${new Date(timestamp).toISOString().replace(/T/, ' ')}]`
+    delete metric['level']
+    console.log(
+      `${asTimestamp(time)} ${level} ` +
+        util.inspect(metric, {
+          colors: true,
+          depth: null,
+          maxArrayLength: Infinity,
+          sorted: true,
+          compact: true,
+          breakLength: Infinity,
+        })
+    )
+  }
+}
+
+export async function getSandboxMetrics({
+  sandboxID,
+}: {
+  sandboxID: string
+}): Promise<e2b.components['schemas']['SandboxMetric'][]> {
+  const signal = connectionConfig.getSignal()
+  const res = await client.api.GET('/sandboxes/{sandboxID}/metrics', {
+    signal,
+    params: {
+      path: {
+        sandboxID,
+      },
+    },
+  })
+
+  handleE2BRequestError(res.error, 'Error while getting sandbox metrics')
+
+  return res.data as e2b.components['schemas']['SandboxMetric'][]
+}

packages/js-sdk/package.json

@@ -35,7 +35,8 @@
     "update-deps": "ncu -u && pnpm i",
     "postPublish": "./scripts/post-publish.sh || true",
     "test:bun": "bun test tests/runtimes/bun --env-file=.env",
-    "test:deno": "deno test tests/runtimes/deno/ --allow-net --allow-read --allow-env --unstable-sloppy-imports --trace-leaks"
+    "test:deno": "deno test tests/runtimes/deno/ --allow-net --allow-read --allow-env --unstable-sloppy-imports --trace-leaks",
+    "test:integration": "E2B_INTEGRATION_TEST=1 vitest run tests/integration/**"
   },
   "devDependencies": {
     "@testing-library/react": "^16.0.1",