v2.5Performance

Performance & Monitoring

Velisch hilft dir, Flaschenhälse zu identifizieren und zu beheben - mit nativen Performance-Tools und Metrics.

Native Rust-Kompilierung

Velisch wird direkt in hochoptimierten Rust-Code übersetzt - keine Interpretation, kein GC-Overhead.

Zero-Cost Abstractions

Abstraktionen ohne Laufzeit-Overhead.

Memory Safety

Garantiert ohne Garbage Collector.

Async/Concurrency

Sichere Parallelverarbeitung von Haus aus.

Benchmark-Vergleich

Framework       | Requests/sec | Latency (p99) | Memory
----------------|--------------|---------------|--------
Velisch 2.5 | 125,000      | 0.8ms         | 12 MB
FastAPI (Py)    | 2,500        | 45ms          | 180 MB
Express (JS)    | 12,000       | 12ms          | 95 MB
Go (Gin)        | 85,000       | 1.2ms         | 18 MB

PerformanceMonitor

Messe granular, wie lange bestimmte Abschnitte deines Codes dauern:

use metrics

let monitor = PerformanceMonitor.new();

fn processOrder(order: Order): OrderResult {
    monitor.start("validate_stock");
    inventory.check(order);
    monitor.stop("validate_stock");
    
    monitor.start("payment");
    payment.process(order);
    monitor.stop("payment");
    
    monitor.start("shipping");
    shipping.schedule(order);
    monitor.stop("shipping");
    
    log.info(monitor.report());
    // Output: { "validate_stock": "12ms", "payment": "156ms", "shipping": "8ms" }
    
    return OrderResult.success(order);
}

Caching

@Controller("/api/stats")
struct StatsController {

    // Cache-Ergebnis für 5 Minuten
    @GET("/daily")
    @Cache(ttl: "5m")
    fn getDailyStats(): Stats {
        // Teure DB Aggregation...
        return db.query(Stats).aggregate(...);
    }
    
    // Cache pro User (Key wird automatisch generiert)
    @Auth
    @GET("/user/:id")
    @Cache(ttl: "10m", key: "user_stats_{id}")
    fn getUserStats(id: string): UserStats {
        return db.aggregate(UserStats, { userId: id });
    }
    
    // Cache invalidieren
    @Auth
    @POST("/user/:id/action")
    @CacheInvalidate("user_stats_{id}")
    fn performAction(id: string): void {
        // Nach dieser Aktion wird der Cache gelöscht
    }
}

MetricsCollector (Prometheus)

Nahtlose Integration mit Prometheus für Produktions-Monitoring:

use metrics

let metrics = MetricsCollector.new();

// Counter für Requests
metrics.increment("http_requests_total", { 
    "method": req.method, 
    "status": res.status,
    "endpoint": req.path
});

// Histogramm für Latenz
let timer = metrics.startTimer("http_request_duration_seconds");
// ... request verarbeiten ...
timer.observe({ "endpoint": req.path });

// Gauge für aktuelle Werte
metrics.gauge("active_connections", connectionPool.activeCount());
metrics.gauge("queue_size", taskQueue.size());

// Prometheus Endpoint
@GET("/metrics")
fn getMetrics(): string {
    return metrics.export();
}

Database Query Optimization

// N+1 Problem vermeiden mit Eager Loading
@GET("/api/orders")
fn getOrders(): List<Order> {
    return db.query(Order)
        .include("user")           // User mitladen
        .include("items.product")  // Items und deren Products
        .findAll();
}

// Query Explain für Debugging
fn analyzeQuery(): QueryPlan {
    return db.query(User)
        .where("active", "=", true)
        .orderBy("createdAt", "DESC")
        .explain();  // Zeigt Query-Plan
}

// Connection Pooling (automatisch)
// Velisch verwaltet einen Connection Pool
// Konfiguration in config.velin:
// db.poolSize = 20
// db.poolTimeout = "30s"

Profiling & Debugging

CPU Profiling

# Mit perf (Linux)
perf record ./my-velin-app
perf report

# Flame Graph generieren
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

Memory Profiling

# Mit Valgrind
valgrind --tool=massif ./my-velin-app

# Oder mit heaptrack
heaptrack ./my-velin-app

Best Practices

Caching nutzen

Cache teure Berechnungen und DB-Queries

Eager Loading

Vermeide N+1 Queries mit .include()

Async I/O

Nutze async/await für I/O-gebundene Operationen

Connection Pooling

Velisch pooled DB-Connections automatisch

Metrics sammeln

Überwache Latenz, Throughput und Fehlerrate

Profiling in Dev

Identifiziere Bottlenecks früh im Entwicklungsprozess

Rate Limiting Profiler