Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

15.6 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import { downloadBlob } from 'lib/components/ExportButton/exporter'
import { dayjs } from 'lib/dayjs'
import { dateStringToDayJs } from 'lib/utils/dateFilters'
import { projectLogic } from 'scenes/projectLogic'

import * as api from '../generated/api'
import type { FeatureFlagRequestUsageItemApi, FeatureFlagRequestUsageResponseApi } from '../generated/api.schemas'

export type FeatureFlagRequestUsageInterval = 'hour' | 'day'
export type FeatureFlagRequestUsageMetric = 'requests' | 'billing_units'
export type FeatureFlagRequestTypeFilter = 'all' | 'remote_evaluation' | 'local_evaluation'

// DateFilter's "Last 7 days" starts at midnight seven days ago and can therefore
// span almost eight elapsed days. Keep this aligned with the backend validator.
export const MAX_HOURLY_RANGE_DAYS = 8

export interface FeatureFlagRequestUsageSeries {
    id: number
    label: string
    data: number[]
    dates: string[]
}

export interface FeatureFlagRequestUsageSdkTotal {
    sdk: string
    remoteRequests: number
    localRequests: number
    localBillingUnits: number
    billingUnits: number
    billingUnitsShare: number
}

interface ResolvedDateRange {
    dateFrom: dayjs.Dayjs
    dateTo: dayjs.Dayjs
}

function resolveDateRange(dateFrom: string, dateTo: string | null): ResolvedDateRange {
    const parsedDateTo = dateTo ? (dateStringToDayJs(dateTo) ?? dayjs(dateTo)) : null
    // A date-only value such as "2026-08-20" represents that entire calendar day.
    const inclusiveDateTo = parsedDateTo && !dateTo?.includes('T') ? parsedDateTo.endOf('day') : parsedDateTo
    return {
        dateFrom: dateStringToDayJs(dateFrom) ?? dayjs().subtract(30, 'day'),
        // The API treats date_to as exclusive, so step past the inclusive picker value.
        dateTo: inclusiveDateTo ? inclusiveDateTo.add(1, 'millisecond') : dayjs(),
    }
}

function seriesLabel(item: FeatureFlagRequestUsageItemApi): string {
    const evaluationLabel = item.request_type === 'remote_evaluation' ? 'remote' : 'local'
    return `${item.sdk} (${evaluationLabel})`
}

function buildDates(dateFrom: string, dateTo: string | null, interval: FeatureFlagRequestUsageInterval): string[] {
    const range = resolveDateRange(dateFrom, dateTo)
    const dates: string[] = []
    let bucket = range.dateFrom.utc().startOf(interval)

    while (bucket.isBefore(range.dateTo)) {
        dates.push(bucket.toISOString())
        bucket = bucket.add(1, interval)
    }
    return dates
}

function filterItems(
    response: FeatureFlagRequestUsageResponseApi | null,
    selectedSDKs: string[],
    requestType: FeatureFlagRequestTypeFilter
): FeatureFlagRequestUsageItemApi[] {
    return (response?.results ?? []).filter(
        (item) =>
            (selectedSDKs.length === 0 || selectedSDKs.includes(item.sdk)) &&
            (requestType === 'all' || item.request_type === requestType)
    )
}

export function csvCell(value: string | number): string {
    const stringValue = String(value)
    const formulaSafeValue = /^[=+\-@\t\r]/.test(stringValue) ? `'${stringValue}` : stringValue
    return `"${formulaSafeValue.replaceAll('"', '""')}"`
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRequestUsageLogicValues {
    currentProjectId: number | null // projectLogic
    dateFrom: string
    dateTo: string | null
    dates: string[]
    filteredItems: FeatureFlagRequestUsageItemApi[]
    interval: FeatureFlagRequestUsageInterval
    isHourlyAvailable: boolean
    largestSdk: FeatureFlagRequestUsageSdkTotal | null
    loadError: boolean
    metric: FeatureFlagRequestUsageMetric
    requestType: FeatureFlagRequestTypeFilter
    sdkOptions: {
        key: string
        label: string
    }[]
    sdkTotals: FeatureFlagRequestUsageSdkTotal[]
    selectedSDKs: string[]
    series: FeatureFlagRequestUsageSeries[]
    totalBillingUnits: number
    totalLocalRequests: number
    totalRemoteRequests: number
    usageResponse: FeatureFlagRequestUsageResponseApi | null
    usageResponseLoading: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRequestUsageLogicActions {
    downloadCsv: () => {
        value: true
    }
    loadUsageResponse: (_: void) => void
    loadUsageResponseFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadUsageResponseSuccess: (
        usageResponse: FeatureFlagRequestUsageResponseApi,
        payload?: void
    ) => {
        usageResponse: FeatureFlagRequestUsageResponseApi
        payload?: void
    }
    setDates: (
        dateFrom: string | null,
        dateTo: string | null
    ) => {
        dateFrom: string | null
        dateTo: string | null
    }
    setInterval: (interval: FeatureFlagRequestUsageInterval) => {
        interval: FeatureFlagRequestUsageInterval
    }
    setMetric: (metric: FeatureFlagRequestUsageMetric) => {
        metric: FeatureFlagRequestUsageMetric
    }
    setRequestType: (requestType: FeatureFlagRequestTypeFilter) => {
        requestType: FeatureFlagRequestTypeFilter
    }
    setSelectedSDKs: (selectedSDKs: string[]) => {
        selectedSDKs: string[]
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface featureFlagRequestUsageLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        isHourlyAvailable: (dateFrom: string, dateTo: string | null) => boolean
        sdkOptions: (usageResponse: FeatureFlagRequestUsageResponseApi | null) => {
            key: string
            label: string
        }[]
        filteredItems: (
            usageResponse: FeatureFlagRequestUsageResponseApi | null,
            selectedSDKs: string[],
            requestType: FeatureFlagRequestTypeFilter
        ) => FeatureFlagRequestUsageItemApi[]
        dates: (dateFrom: string, dateTo: string | null, interval: FeatureFlagRequestUsageInterval) => string[]
        series: (
            filteredItems: FeatureFlagRequestUsageItemApi[],
            usageResponse: FeatureFlagRequestUsageResponseApi | null,
            dates: string[],
            metric: FeatureFlagRequestUsageMetric,
            interval: FeatureFlagRequestUsageInterval
        ) => FeatureFlagRequestUsageSeries[]
        sdkTotals: (filteredItems: FeatureFlagRequestUsageItemApi[]) => FeatureFlagRequestUsageSdkTotal[]
        totalRemoteRequests: (filteredItems: FeatureFlagRequestUsageItemApi[]) => number
        totalLocalRequests: (filteredItems: FeatureFlagRequestUsageItemApi[]) => number
        totalBillingUnits: (filteredItems: FeatureFlagRequestUsageItemApi[]) => number
        largestSdk: (sdkTotals: FeatureFlagRequestUsageSdkTotal[]) => FeatureFlagRequestUsageSdkTotal | null
    }
}

export type featureFlagRequestUsageLogicType = MakeLogicType<
    featureFlagRequestUsageLogicValues,
    featureFlagRequestUsageLogicActions,
    Record<string, any>,
    featureFlagRequestUsageLogicMeta
>

export const featureFlagRequestUsageLogic = kea<featureFlagRequestUsageLogicType>([
    path(['products', 'featureFlags', 'requestUsage', 'featureFlagRequestUsageLogic']),
    connect(() => ({ values: [projectLogic, ['currentProjectId']] })),
    actions({
        setInterval: (interval: FeatureFlagRequestUsageInterval) => ({ interval }),
        setDates: (dateFrom: string | null, dateTo: string | null) => ({ dateFrom, dateTo }),
        setMetric: (metric: FeatureFlagRequestUsageMetric) => ({ metric }),
        setRequestType: (requestType: FeatureFlagRequestTypeFilter) => ({ requestType }),
        setSelectedSDKs: (selectedSDKs: string[]) => ({ selectedSDKs }),
        downloadCsv: true,
    }),
    loaders(({ values }) => ({
        usageResponse: [
            null as FeatureFlagRequestUsageResponseApi | null,
            {
                loadUsageResponse: async (_: void, breakpoint) => {
                    if (!values.currentProjectId) {
                        throw new Error('No project selected')
                    }
                    const range = resolveDateRange(values.dateFrom, values.dateTo)
                    const params = {
                        date_from: range.dateFrom.toISOString(),
                        date_to: range.dateTo.toISOString(),
                        time_interval: values.interval,
                    }
                    const response = await api.featureFlagRequestUsageList(String(values.currentProjectId), params)
                    breakpoint()
                    return response
                },
            },
        ],
    })),
    reducers({
        interval: ['day' as FeatureFlagRequestUsageInterval, { setInterval: (_, { interval }) => interval }],
        dateFrom: ['-30d', { setDates: (_, { dateFrom }) => dateFrom ?? '-30d' }],
        dateTo: [null as string | null, { setDates: (_, { dateTo }) => dateTo }],
        metric: ['requests' as FeatureFlagRequestUsageMetric, { setMetric: (_, { metric }) => metric }],
        requestType: ['all' as FeatureFlagRequestTypeFilter, { setRequestType: (_, { requestType }) => requestType }],
        selectedSDKs: [[] as string[], { setSelectedSDKs: (_, { selectedSDKs }) => selectedSDKs }],
        loadError: [
            false,
            {
                loadUsageResponse: () => false,
                loadUsageResponseSuccess: () => false,
                loadUsageResponseFailure: () => true,
            },
        ],
    }),
    selectors({
        isHourlyAvailable: [
            (s) => [s.dateFrom, s.dateTo],
            (dateFrom: string, dateTo: string | null): boolean => {
                const range = resolveDateRange(dateFrom, dateTo)
                return range.dateTo.diff(range.dateFrom, 'day', true) <= MAX_HOURLY_RANGE_DAYS
            },
        ],
        sdkOptions: [
            (s) => [s.usageResponse],
            (response: FeatureFlagRequestUsageResponseApi | null): { key: string; label: string }[] =>
                Array.from(new Set(response?.results.map(({ sdk }) => sdk) ?? []))
                    .sort()
                    .map((sdk) => ({ key: sdk, label: sdk })),
        ],
        filteredItems: [
            (s) => [s.usageResponse, s.selectedSDKs, s.requestType],
            (
                response: FeatureFlagRequestUsageResponseApi | null,
                selectedSDKs: string[],
                requestType: FeatureFlagRequestTypeFilter
            ): FeatureFlagRequestUsageItemApi[] => filterItems(response, selectedSDKs, requestType),
        ],
        dates: [
            (s) => [s.dateFrom, s.dateTo, s.interval],
            (dateFrom: string, dateTo: string | null, interval: FeatureFlagRequestUsageInterval): string[] =>
                buildDates(dateFrom, dateTo, interval),
        ],
        series: [
            (s) => [s.filteredItems, s.usageResponse, s.dates, s.metric, s.interval],
            (
                items: FeatureFlagRequestUsageItemApi[],
                response: FeatureFlagRequestUsageResponseApi | null,
                dates: string[],
                metric: FeatureFlagRequestUsageMetric,
                interval: FeatureFlagRequestUsageInterval
            ): FeatureFlagRequestUsageSeries[] => {
                const allLabels = Array.from(new Set(response?.results.map(seriesLabel) ?? [])).sort()
                const seriesByLabel = new Map<string, Map<string, number>>()
                for (const item of items) {
                    const label = seriesLabel(item)
                    const values = seriesByLabel.get(label) ?? new Map<string, number>()
                    const value = metric === 'requests' ? item.request_count : item.billing_units
                    const bucket = dayjs(item.bucket).utc().startOf(interval).toISOString()
                    values.set(bucket, (values.get(bucket) ?? 0) + value)
                    seriesByLabel.set(label, values)
                }
                return Array.from(seriesByLabel.entries()).map(([label, values]) => ({
                    id: allLabels.indexOf(label),
                    label,
                    dates,
                    data: dates.map((date) => values.get(date) ?? 0),
                }))
            },
        ],
        sdkTotals: [
            (s) => [s.filteredItems],
            (items: FeatureFlagRequestUsageItemApi[]): FeatureFlagRequestUsageSdkTotal[] => {
                const totals = new Map<string, FeatureFlagRequestUsageSdkTotal>()
                for (const item of items) {
                    const current = totals.get(item.sdk) ?? {
                        sdk: item.sdk,
                        remoteRequests: 0,
                        localRequests: 0,
                        localBillingUnits: 0,
                        billingUnits: 0,
                        billingUnitsShare: 0,
                    }
                    if (item.request_type === 'remote_evaluation') {
                        current.remoteRequests += item.request_count
                    } else {
                        current.localRequests += item.request_count
                        current.localBillingUnits += item.billing_units
                    }
                    current.billingUnits += item.billing_units
                    totals.set(item.sdk, current)
                }
                const totalBillingUnits = Array.from(totals.values()).reduce((sum, item) => sum + item.billingUnits, 0)
                for (const item of totals.values()) {
                    item.billingUnitsShare = totalBillingUnits === 0 ? 0 : (item.billingUnits / totalBillingUnits) * 100
                }
                return Array.from(totals.values()).sort((a, b) => b.billingUnits - a.billingUnits)
            },
        ],
        totalRemoteRequests: [
            (s) => [s.filteredItems],
            (items: FeatureFlagRequestUsageItemApi[]): number =>
                items.reduce(
                    (total, item) => total + (item.request_type === 'remote_evaluation' ? item.request_count : 0),
                    0
                ),
        ],
        totalLocalRequests: [
            (s) => [s.filteredItems],
            (items: FeatureFlagRequestUsageItemApi[]): number =>
                items.reduce(
                    (total, item) => total + (item.request_type === 'local_evaluation' ? item.request_count : 0),
                    0
                ),
        ],
        totalBillingUnits: [
            (s) => [s.filteredItems],
            (items: FeatureFlagRequestUsageItemApi[]): number =>
                items.reduce((total, item) => total + item.billing_units, 0),
        ],
        largestSdk: [
            (s) => [s.sdkTotals],
            (sdkTotals: FeatureFlagRequestUsageSdkTotal[]): FeatureFlagRequestUsageSdkTotal | null =>
                sdkTotals[0] ?? null,
        ],
    }),
    listeners(({ actions, values }) => ({
        setInterval: () => actions.loadUsageResponse(),
        setDates: () => {
            if (!values.isHourlyAvailable) {
                actions.setInterval('day')
            } else {
                actions.loadUsageResponse()
            }
        },
        downloadCsv: () => {
            const header = ['bucket', 'sdk', 'request_type', 'request_count', 'billing_units']
            const rows = values.filteredItems.map((item) => [
                item.bucket,
                item.sdk,
                item.request_type,
                item.request_count,
                item.billing_units,
            ])
            const csv = [header, ...rows].map((row) => row.map(csvCell).join(',')).join('\n')
            downloadBlob(new Blob([csv], { type: 'text/csv;charset=utf-8' }), `feature-flag-request-usage.csv`)
        },
    })),
    afterMount(({ actions }) => actions.loadUsageResponse()),
])