Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
5.0 KB
Raw Blame
import { Request, Response, Router } from 'express'
import {
  type UsageFilters,
  type UsageGroupBy,
  type UsageInterval,
  checkIntervalCoversRange,
  isAllowedGroupBy,
  isUsageInterval,
  queryUsageSeries,
  queryUsageTotals,
} from '../../services/usageReader.js'

type ParsedQuery = {
  from: Date
  to: Date
  interval: UsageInterval
  groupBy: UsageGroupBy
  filters: UsageFilters
  limit?: number
}

type ParseError = { error: string; detail?: string }

function parseDate(raw: unknown, field: string): Date | ParseError {
  if (typeof raw !== 'string' || raw.trim().length === 0) {
    return { error: 'invalid_query', detail: `${field} is required` }
  }
  const d = new Date(raw)
  if (Number.isNaN(d.getTime())) {
    return { error: 'invalid_query', detail: `${field} is not a valid ISO date` }
  }
  return d
}

function parseFilters(raw: unknown): UsageFilters | ParseError {
  if (raw === undefined || raw === null) return {}
  let obj: unknown
  if (typeof raw === 'string') {
    if (raw.trim().length === 0) return {}
    try {
      obj = JSON.parse(raw)
    } catch {
      return { error: 'invalid_query', detail: 'filters is not valid JSON' }
    }
  } else if (typeof raw === 'object') {
    obj = raw
  } else {
    return { error: 'invalid_query', detail: 'filters must be a JSON object' }
  }
  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
    return { error: 'invalid_query', detail: 'filters must be a JSON object' }
  }
  const out: UsageFilters = {}
  for (const [key, value] of Object.entries(obj)) {
    if (!isAllowedGroupBy(key)) {
      return { error: 'invalid_query', detail: `unknown filter dimension: ${key}` }
    }
    if (!Array.isArray(value)) {
      return { error: 'invalid_query', detail: `filter ${key} must be an array of strings` }
    }
    const values: string[] = []
    for (const v of value) {
      if (typeof v !== 'string') {
        return { error: 'invalid_query', detail: `filter ${key} contains a non-string value` }
      }
      values.push(v)
    }
    if (values.length > 0) out[key] = values
  }
  return out
}

function parseQuery(req: Request, withLimit: boolean): ParsedQuery | ParseError {
  const fromRes = parseDate(req.query.from, 'from')
  if (fromRes instanceof Date === false) return fromRes as ParseError
  const toRes = parseDate(req.query.to, 'to')
  if (toRes instanceof Date === false) return toRes as ParseError
  const from = fromRes as Date
  const to = toRes as Date
  if (!(from.getTime() < to.getTime())) {
    return { error: 'invalid_query', detail: 'from must be earlier than to' }
  }

  const interval = req.query.interval
  if (!isUsageInterval(interval)) {
    return { error: 'invalid_query', detail: 'interval must be one of: 5min, hour, day' }
  }

  const groupBy = req.query.groupBy
  if (!isAllowedGroupBy(groupBy)) {
    return { error: 'invalid_query', detail: 'groupBy is required and must be a known dimension' }
  }

  const rangeErr = checkIntervalCoversRange(interval, from)
  if (rangeErr) {
    return {
      error: rangeErr.error,
      detail: `interval=${interval} only covers the last ${rangeErr.retentionDays} days`,
    }
  }

  const filtersRes = parseFilters(req.query.filters)
  if ('error' in filtersRes) return filtersRes

  let limit: number | undefined
  if (withLimit && req.query.limit !== undefined) {
    const raw = Number(req.query.limit)
    if (!Number.isFinite(raw) || raw < 1) {
      return { error: 'invalid_query', detail: 'limit must be a positive integer' }
    }
    limit = raw
  }

  return { from, to, interval, groupBy, filters: filtersRes, limit }
}

export function createAdminUsageRouter(): Router {
  const router = Router()

  router.get('/admin/usage/llm', async (req: Request, res: Response, next) => {
    try {
      const parsed = parseQuery(req, false)
      if ('error' in parsed) {
        res.status(400).json(parsed)
        return
      }
      const rows = await queryUsageSeries({
        from: parsed.from,
        to: parsed.to,
        interval: parsed.interval,
        groupBy: parsed.groupBy,
        filters: parsed.filters,
      })
      res.status(200).json({
        from: parsed.from.toISOString(),
        to: parsed.to.toISOString(),
        interval: parsed.interval,
        groupBy: parsed.groupBy,
        rows,
      })
    } catch (error) {
      next(error)
    }
  })

  router.get('/admin/usage/llm/totals', async (req: Request, res: Response, next) => {
    try {
      const parsed = parseQuery(req, true)
      if ('error' in parsed) {
        res.status(400).json(parsed)
        return
      }
      const rows = await queryUsageTotals({
        from: parsed.from,
        to: parsed.to,
        interval: parsed.interval,
        groupBy: parsed.groupBy,
        filters: parsed.filters,
        limit: parsed.limit,
      })
      res.status(200).json({
        from: parsed.from.toISOString(),
        to: parsed.to.toISOString(),
        interval: parsed.interval,
        groupBy: parsed.groupBy,
        rows,
      })
    } catch (error) {
      next(error)
    }
  })

  return router
}