Belajar ElysiaJS - Performance Optimization & Profiling

#Pendahuluan

Setelah di episode 15 kita meng-setup OpenAPI documentation, pada episode ini kita akan memahami cara mengoptimasi performa ElysiaJS — krusial untuk high-traffic API di mana setiap milidetik latency berdampak pada user experience dan biaya infrastruktur.

#Benchmarking ElysiaJS

#Tools Benchmarking

Install autocannon untuk benchmarking

bun add -g autocannon

Jalankan benchmark

autocannon -c 100 -d 10 http://localhost:3000

Parameter -c 100 artinya 100 koneksi concurrent, -d 10 artinya durasi 10 detik. Target untuk simple route di Bun: 500k+ req/s.

#Benchmark yang Meaningful

Jangan hanya benchmark route kosong. Benchmark dengan kondisi realistis:

Benchmark dengan payload

autocannon -c 100 -d 10 -m POST \
  -H "Content-Type=application/json" \
  -b '{"name":"test","email":"test@example.com"}' \
  http://localhost:3000/users

#Optimization Techniques

#Pre-compile Schema

ElysiaJS secara otomatis cache schema validation, tetapi kalian bisa memastikan schema di-pre-compile:

Pre-compile schema untuk performa

import { Elysia, t } from 'elysia'
 
// Schema didefinisikan di level modul — di-cache oleh ElysiaJS
const createUserSchema = t.Object({
  name: t.String(),
  email: t.String({ format: 'email' }),
})
 
const app = new Elysia()
  .post('/users', handler, { body: createUserSchema })

#Connection Pooling Database

Connection pooling untuk PostgreSQL

import { Pool } from 'pg'
 
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 20,
  idleTimeoutMillis: 30000,
})

Jangan buka/tutup koneksi per request — ini sangat mahal.

#Response Compression

Install compression plugin

bun add @elysiajs/compress

Setup response compression

import compress from '@elysiajs/compress'
 
const app = new Elysia()
  .use(compress())

#Profiling

#Bun Inspector

Jalankan dengan inspector

bun --inspect src/index.ts

Buka chrome://inspect di Chrome DevTools untuk profiling CPU dan memory.

#Memory Leak Detection

Monitor RSS (Resident Set Size) di production:

Monitor memory usage

ps aux | grep bun | grep -v grep

RSS tidak boleh terus meningkat tanpa batas — ini indikasi memory leak.

#Caching Strategy

#In-Memory Cache

LRU cache untuk data read-heavy

const cache = new Map<string, { data: any, expiry: number }>()
 
function getCached(key: string, ttl: number) {
  const cached = cache.get(key)
  if (cached && cached.expiry > Date.now()) {
    return cached.data
  }
  return null
}

#HTTP Caching

Cache-Control headers

.get('/data', ({ set }) => {
  set.headers['Cache-Control'] = 'public, max-age=3600'
  return { data: 'expensive computation' }
})

#Redis untuk Distributed Cache

Untuk multiple instances, gunakan Redis:

Redis cache integration

import Redis from 'ioredis'
 
const redis = new Redis(process.env.REDIS_URL)
 
app.get('/data', async () => {
  const cached = await redis.get('data')
  if (cached) return JSON.parse(cached)
 
  const data = await expensiveQuery()
  await redis.set('data', JSON.stringify(data), 'EX', 3600)
  return data
})

Note

Caching harus diterapkan secara selektif. Data yang sering berubah (real-time) sebaiknya tidak di-cache. Data yang jarang berubah (configuration, reference data) sangat cocok untuk caching agresif.

#Penutup

Pada episode 16 ini, kalian telah memahami cara mengoptimasi performa ElysiaJS — dari benchmarking hingga caching strategy.

Inti yang harus dibawa pulang:

Benchmark dengan autocannon: target 500k+ req/s untuk simple routes.
Pre-compile schema dan connection pooling untuk performa.
Bun inspector untuk profiling CPU dan memory.
Caching strategy: in-memory, HTTP headers, dan Redis.

Di episode 17 selanjutnya kita akan memahami testing dengan Bun test dan supertest — unit testing, integration testing, E2E testing, dan code coverage. Sampai jumpa di episode 17!