Performance Testing

Performance Testing

Performance Testing Types

Load Testing

Purpose: Verify system performance under expected load

• Simulates expected user traffic and data volume
• Identifies performance bottlenecks under normal conditions
• Establishes performance baselines
• Validates SLA compliance

Key Metrics:

• Response time (average, median, p95, p99)
• Throughput (requests per second, transactions per second)
• Error rate
• Resource utilization (CPU, memory, disk, network)

Stress Testing

Purpose: Identify system breaking points

• Exceeds expected load to find limits
• Tests system recovery after failure
• Identifies failure modes and error handling
• Validates graceful degradation

Key Metrics:

• Maximum concurrent users before failure
• Maximum throughput before failure
• Time to recover after load reduction
• Error patterns and failure modes

Spike Testing

Purpose: Handle sudden traffic increases

• Simulates sudden traffic spikes (e.g., flash sales, viral content)
• Tests system elasticity and auto-scaling
• Validates queuing and throttling mechanisms
• Identifies race conditions under load

Key Metrics:

• Response time during spike
• Error rate during spike
• Time to stabilize after spike
• Queue depth and processing time

Soak Testing

Purpose: Verify stability over extended periods

• Runs sustained load for hours or days
• Identifies memory leaks and resource exhaustion
• Tests database connection pool stability
• Validates garbage collection efficiency

Key Metrics:

• Memory usage over time
• Response time trends
• Error rate over time
• Resource utilization trends

Volume Testing

Purpose: Test with large data volumes

• Tests performance with realistic data sizes
• Identifies database query performance issues
• Tests file system and storage performance
• Validates data migration performance

Key Metrics:

• Query execution time with large datasets
• Index usage and effectiveness
• Storage I/O performance
• Data processing throughput

Performance Testing Tools

JMeter

Best for: Load and stress testing

• Open source, Java-based
• Supports multiple protocols (HTTP, JDBC, JMS, etc.)
• Distributed testing support
• Extensive plugin ecosystem
• GUI and CLI modes

<!-- JMeter Test Plan Example -->
<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan>
  <hashTree>
    <TestPlan guiclass="TestPlanGui">
      <stringProp name="TestPlan.comments">Load Test</stringProp>
    </TestPlan>
    <hashTree>
      <ThreadGroup guiclass="ThreadGroupGui">
        <stringProp name="ThreadGroup.num_threads">100</stringProp>
        <stringProp name="ThreadGroup.ramp_time">10</stringProp>
        <stringProp name="ThreadGroup.duration">60</stringProp>
      </ThreadGroup>
      <hashTree>
        <HTTPSamplerProxy guiclass="HttpTestSampleGui">
          <stringProp name="HTTPSampler.domain">example.com</stringProp>
          <stringProp name="HTTPSampler.path">/api/users</stringProp>
        </HTTPSamplerProxy>
      </hashTree>
    </hashTree>
  </hashTree>
</jmeterTestPlan>

Gatling

Best for: High-performance load testing

• Scala-based, DSL for test scenarios
• High performance, low resource usage
• Real-time metrics and reporting
• Good for continuous integration
• Supports HTTP, WebSocket, JMS

// Gatling Example
import io.gatling.core.Predef._
import io.gatling.http.Predef._

class LoadTest extends Simulation {
  val httpProtocol = http.baseUrl("https://example.com")
  
  val scn = scenario("User Journey")
    .exec(http("Get Users").get("/api/users"))
    .pause(1)
    .exec(http("Get User").get("/api/users/1"))
  
  setUp(
    scn.inject(
      rampUsers(100).during(10.seconds),
      constantUsersPerSec(50).during(60.seconds)
    )
  ).protocols(httpProtocol)
}

k6

Best for: Developer-friendly performance testing

• JavaScript-based, easy to learn
• Modern CLI and cloud integration
• Good for CI/CD pipelines
• Supports HTTP/1.1, HTTP/2, WebSocket
• Grafana integration for visualization

// k6 Example
import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
  stages: [
    { duration: '10s', target: 100 },
    { duration: '60s', target: 100 },
    { duration: '10s', target: 0 },
  ],
};

export default function () {
  let res = http.get('https://example.com/api/users');
  check(res, {
    'status was 200': (r) => r.status == 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
  sleep(1);
}

Locust

Best for: Python-based load testing

• Python-based, easy to write tests
• Web UI for real-time monitoring
• Distributed testing support
• Good for complex user scenarios
• Event-based architecture

# Locust Example
from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
    wait_time = between(1, 3)
    
    @task
    def get_users(self):
        self.client.get("/api/users")
    
    @task(2)
    def get_user(self):
        self.client.get("/api/users/1")

Key Performance Metrics

Response Time

• Average: Mean response time across all requests
• Median: Middle value, less affected by outliers
• p95: 95th percentile, 95% of requests complete within this time
• p99: 99th percentile, 99% of requests complete within this time
• Min/Max: Fastest and slowest response times

Throughput

• Requests Per Second (RPS): Number of requests handled per second
• Transactions Per Second (TPS): Number of business transactions per second
• Concurrent Users: Number of simultaneous users
• Hits Per Second: Number of HTTP requests per second

Error Rate

• HTTP Error Rate: Percentage of HTTP errors (4xx, 5xx)
• Application Error Rate: Percentage of application-level errors
• Timeout Rate: Percentage of requests that timed out
• Connection Error Rate: Percentage of connection failures

Resource Utilization

• CPU Usage: Processor utilization percentage
• Memory Usage: RAM consumption and availability
• Disk I/O: Read/write operations and latency
• Network I/O: Bandwidth utilization and latency
• Database Connections: Active and idle connection counts

Performance Profiling

Application Profiling

• CPU Profiling: Identify CPU-intensive methods
• Memory Profiling: Detect memory leaks and allocation patterns
• Thread Profiling: Identify thread contention and deadlocks
• Database Profiling: Analyze query performance and execution plans

Tools

• Java: JProfiler, VisualVM, YourKit
• Node.js: Node.js Profiler, Clinic.js
• Python: cProfile, Py-Spy
• Go: pprof
• .NET: dotTrace, Visual Studio Profiler

Bottleneck Identification

1. Database: Slow queries, missing indexes, N+1 queries
2. Network: Latency, bandwidth limitations, connection pooling
3. Application: Inefficient algorithms, excessive object creation
4. External Services: Third-party API latency, rate limiting
5. Caching: Cache misses, stale data, cache stampede

Performance Baselines and SLAs

Establishing Baselines

• Run tests in production-like environment
• Collect metrics over multiple runs
• Account for normal variability
• Document test conditions and data
• Store baselines in version control

SLA Definitions

• Response Time SLAs: Maximum acceptable response times
• Availability SLAs: Minimum uptime requirements (e.g., 99.9%)
• Throughput SLAs: Minimum requests per second
• Error Rate SLAs: Maximum acceptable error rate

Example SLAs

API Response Times:
- p50 < 200ms
- p95 < 500ms
- p99 < 1000ms

Availability: 99.9% (8.76 hours downtime/year)

Error Rate: < 0.1%

Throughput: 1000 RPS

Cloud-Based Performance Testing

Cloud Testing Benefits

• Scalable infrastructure on demand
• Geographic distribution
• Realistic load simulation
• Pay-as-you-go pricing
• Integration with cloud services

Cloud Testing Platforms

• AWS: EC2, Lambda, Fargate for distributed testing
• Google Cloud: Compute Engine, Cloud Functions
• Azure: Virtual Machines, Azure Functions
• Managed Services: BlazeMeter, LoadRunner Cloud, k6 Cloud

Cloud Testing Best Practices

• Use multiple regions for geographic testing
• Leverage auto-scaling for flexible load
• Monitor cloud costs during testing
• Clean up resources after testing
• Use cloud-native monitoring and logging

Performance Test Planning

Test Scenarios

• Define realistic user journeys
• Identify critical paths
• Include happy path and edge cases
• Account for different user types
• Consider peak and off-peak patterns

Load Models

• Constant Load: Steady user count over time
• Ramp-up Load: Gradually increase users
• Spike Load: Sudden increase in users
• Step Load: Incremental increases with plateaus
• Random Load: Variable user patterns

Test Data

• Use realistic data volumes
• Include edge cases and boundary values
• Account for data distribution
• Refresh data between test runs
• Consider data privacy and security

Environment Setup

• Mirror production configuration
• Use production-like data
• Monitor system resources
• Isolate test environment
• Document environment differences