posthog-performance-tuning
Optimize PostHog API performance with caching, batching, and connection pooling.Use when experiencing slow API responses, implementing caching strategies,or optimizing request throughput for PostHog integrations.Trigger with phrases like "posthog performance", "optimize posthog","posthog latency", "posthog caching", "posthog slow", "posthog batch".
When & Why to Use This Skill
This Claude skill provides a comprehensive suite of optimization strategies and production-ready code patterns to enhance PostHog API performance. It focuses on reducing latency and maximizing request throughput by implementing advanced techniques such as multi-layer caching (LRU and Redis), request batching via DataLoader, and efficient connection pooling. It is designed to help developers build scalable, high-performance analytics integrations while maintaining system stability.
Use Cases
- Case 1: Reducing API response times for frequently accessed analytics data by implementing local memory or distributed Redis caching layers.
- Case 2: Optimizing high-frequency data ingestion and preventing rate-limiting issues by batching multiple PostHog requests into single, efficient operations.
- Case 3: Improving application resource management by configuring persistent connection pooling and HTTP keep-alive for PostHog client integrations.
- Case 4: Benchmarking and monitoring integration performance to identify bottlenecks and ensure PostHog operations meet P95/P99 latency targets.
| name | posthog-performance-tuning |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
PostHog Performance Tuning
Overview
Optimize PostHog API performance with caching, batching, and connection pooling.
Prerequisites
- PostHog SDK installed
- Understanding of async patterns
- Redis or in-memory cache available (optional)
- Performance monitoring in place
Latency Benchmarks
| Operation | P50 | P95 | P99 |
|---|---|---|---|
| Read | 50ms | 150ms | 300ms |
| Write | 100ms | 250ms | 500ms |
| List | 75ms | 200ms | 400ms |
Caching Strategy
Response Caching
import { LRUCache } from 'lru-cache';
const cache = new LRUCache<string, any>({
max: 1000,
ttl: 60000, // 1 minute
updateAgeOnGet: true,
});
async function cachedPostHogRequest<T>(
key: string,
fetcher: () => Promise<T>,
ttl?: number
): Promise<T> {
const cached = cache.get(key);
if (cached) return cached as T;
const result = await fetcher();
cache.set(key, result, { ttl });
return result;
}
Redis Caching (Distributed)
import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);
async function cachedWithRedis<T>(
key: string,
fetcher: () => Promise<T>,
ttlSeconds = 60
): Promise<T> {
const cached = await redis.get(key);
if (cached) return JSON.parse(cached);
const result = await fetcher();
await redis.setex(key, ttlSeconds, JSON.stringify(result));
return result;
}
Request Batching
import DataLoader from 'dataloader';
const posthogLoader = new DataLoader<string, any>(
async (ids) => {
// Batch fetch from PostHog
const results = await posthogClient.batchGet(ids);
return ids.map(id => results.find(r => r.id === id) || null);
},
{
maxBatchSize: 100,
batchScheduleFn: callback => setTimeout(callback, 10),
}
);
// Usage - automatically batched
const [item1, item2, item3] = await Promise.all([
posthogLoader.load('id-1'),
posthogLoader.load('id-2'),
posthogLoader.load('id-3'),
]);
Connection Optimization
import { Agent } from 'https';
// Keep-alive connection pooling
const agent = new Agent({
keepAlive: true,
maxSockets: 10,
maxFreeSockets: 5,
timeout: 30000,
});
const client = new PostHogClient({
apiKey: process.env.POSTHOG_API_KEY!,
httpAgent: agent,
});
Pagination Optimization
async function* paginatedPostHogList<T>(
fetcher: (cursor?: string) => Promise<{ data: T[]; nextCursor?: string }>
): AsyncGenerator<T> {
let cursor: string | undefined;
do {
const { data, nextCursor } = await fetcher(cursor);
for (const item of data) {
yield item;
}
cursor = nextCursor;
} while (cursor);
}
// Usage
for await (const item of paginatedPostHogList(cursor =>
posthogClient.list({ cursor, limit: 100 })
)) {
await process(item);
}
Performance Monitoring
async function measuredPostHogCall<T>(
operation: string,
fn: () => Promise<T>
): Promise<T> {
const start = performance.now();
try {
const result = await fn();
const duration = performance.now() - start;
console.log({ operation, duration, status: 'success' });
return result;
} catch (error) {
const duration = performance.now() - start;
console.error({ operation, duration, status: 'error', error });
throw error;
}
}
Instructions
Step 1: Establish Baseline
Measure current latency for critical PostHog operations.
Step 2: Implement Caching
Add response caching for frequently accessed data.
Step 3: Enable Batching
Use DataLoader or similar for automatic request batching.
Step 4: Optimize Connections
Configure connection pooling with keep-alive.
Output
- Reduced API latency
- Caching layer implemented
- Request batching enabled
- Connection pooling configured
Error Handling
| Issue | Cause | Solution |
|---|---|---|
| Cache miss storm | TTL expired | Use stale-while-revalidate |
| Batch timeout | Too many items | Reduce batch size |
| Connection exhausted | No pooling | Configure max sockets |
| Memory pressure | Cache too large | Set max cache entries |
Examples
Quick Performance Wrapper
const withPerformance = <T>(name: string, fn: () => Promise<T>) =>
measuredPostHogCall(name, () =>
cachedPostHogRequest(`cache:${name}`, fn)
);
Resources
Next Steps
For cost optimization, see posthog-cost-tuning.