1. Requirements Gathering
   ↓ Identify performance goals and SLAs
   
2. Test Planning
   ↓ Define scenarios, metrics, and success criteria
   
3. Test Environment Setup
   ↓ Configure infrastructure matching production
   
4. Script Development
   ↓ Create test scripts and scenarios
   
5. Test Execution
   ↓ Run tests and monitor system behavior
   
6. Analysis & Reporting
   ↓ Identify bottlenecks and provide recommendations
   
7. Optimization & Retest
   ↓ Validate improvements and iterate

pipeline {
    agent any
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        
        stage('Smoke Performance Test') {
            steps {
                // Quick 5-minute test with 50 users
                sh 'jmeter -n -t smoke-test.jmx -l results.jtl'
                
                script {
                    def avgResponseTime = readJMeterResults('results.jtl')
                    if (avgResponseTime > 2000) {
                        error "Performance degradation detected!"
                    }
                }
            }
        }
    }
}

# 1. Download from https://jmeter.apache.org
# 2. Extract to C:\jmeter
# 3. Test installation

cd C:\jmeter\bin
jmeter -v

# Launch GUI
jmeter.bat

# Using Homebrew (macOS)
brew install jmeter

# Manual installation
wget https://dlcdn.apache.org/jmeter/binaries/apache-jmeter-5.6.tgz
tar -xzf apache-jmeter-5.6.tgz
./bin/jmeter -v

Test Plan
 ├── Thread Group (Virtual Users)
 │   ├── Samplers (Requests)
 │   │   ├── HTTP Request
 │   │   └── JDBC Request
 │   ├── Config Elements
 │   │   ├── CSV Data Set
 │   │   └── HTTP Cookie Manager
 │   ├── Timers (Think Time)
 │   ├── Assertions (Validations)
 │   └── Listeners (Reports)

// Right-click Test Plan → Add → Threads → Thread Group

Number of Threads: 100
Ramp-Up Period: 60 seconds
Loop Count: 10

// This creates 100 users over 60 seconds
// Each user executes test 10 times
// Total: 1,000 requests

Protocol: https
Server: api.example.com
Method: GET
Path: /users/${__Random(1,100)}

// ${__Random(1,100)} generates random IDs 1-100

// Extract auth token from login response

Variable name: auth_token
JSON Path: $.token
Match No: 0
Default: TOKEN_ERROR

// Use in next request header:
Authorization: Bearer ${auth_token}

// users.csv file:
username,password,email
testuser1,pass123,user1@test.com
testuser2,pass456,user2@test.com

// Config:
Filename: users.csv
Variable Names: username,password,email
Recycle on EOF: True

// Use in request:
{
  "username": "${username}",
  "password": "${password}"
}

# Basic execution
jmeter -n -t test.jmx -l results.jtl

# With HTML report
jmeter -n -t test.jmx -l results.jtl -e -o html-report

# Override parameters
jmeter -n -t test.jmx -l results.jtl -Jthreads=200

# Download bundle
wget https://repo1.maven.org/maven2/io/gatling/highcharts/\
gatling-charts-highcharts-bundle/3.9.5/\
gatling-charts-highcharts-bundle-3.9.5-bundle.zip

unzip gatling-charts-highcharts-bundle-3.9.5-bundle.zip
cd gatling-charts-highcharts-bundle-3.9.5

# Test installation
./bin/gatling.sh -v

package simulations

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class BasicSimulation extends Simulation {

  // HTTP configuration
  val httpProtocol = http
    .baseUrl("https://api.example.com")
    .acceptHeader("application/json")
    .userAgentHeader("Gatling Load Test")

  // Scenario definition
  val scn = scenario("Basic API Test")
    .exec(
      http("Get Users")
        .get("/users")
        .check(status.is(200))
    )
    .pause(2) // Think time

  // Load injection
  setUp(
    scn.inject(
      rampUsers(100) during (60 seconds)
    )
  ).protocols(httpProtocol)
}

val browseProducts = scenario("Browse & Purchase")
  .exec(http("Homepage").get("/"))
  .pause(2, 5)
  
  .exec(
    http("Search Products")
      .get("/api/products?q=laptop")
      .check(jsonPath("$.products[0].id").saveAs("productId"))
  )
  .pause(3)
  
  .exec(
    http("View Product")
      .get("/api/products/${productId}")
  )
  .pause(5, 10)
  
  .exec(
    http("Add to Cart")
      .post("/api/cart")
      .body(StringBody("""{"productId":"${productId}","qty":1}"""))
      .asJson
  )

// Constant load
constantUsersPerSec(10) during (5 minutes)

// Ramp up
rampUsers(1000) during (10 minutes)

// Steps
incrementUsersPerSec(5)
  .times(10)
  .eachLevelLasting(30 seconds)

// Spike
atOnceUsers(5000)

# Interactive mode
./bin/gatling.sh

# Non-interactive (CI/CD)
./bin/gatling.sh -sf simulations -s BasicSimulation

# Results in: results/basicsimulation-[timestamp]/index.html

# macOS
brew install k6

# Windows (Chocolatey)
choco install k6

# Linux
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg \
  --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] \
https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

# Verify
k6 version

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

// Test configuration
export const options = {
  vus: 10,           // Virtual users
  duration: '30s',   // Test duration
};

// Main test function
export default function() {
  const res = http.get('https://test-api.k6.io');
  
  // Assertions
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
  
  sleep(1);
}

k6 run simple-test.js

export const options = {
  stages: [
    { duration: '2m', target: 100 },  // Ramp up
    { duration: '5m', target: 100 },  // Stay at 100
    { duration: '2m', target: 200 },  // Ramp to 200
    { duration: '2m', target: 0 },    // Ramp down
  ],
  
  thresholds: {
    'http_req_duration': ['p(95)<2000'],  // 95% < 2s
    'http_req_failed': ['rate<0.01'],     // Error < 1%
  },
};

import http from 'k6/http';
import { check } from 'k6';

export default function() {
  // Login and extract token
  const loginRes = http.post('https://api.example.com/login', 
    JSON.stringify({
      username: 'testuser',
      password: 'pass123'
    }),
    { headers: { 'Content-Type': 'application/json' } }
  );
  
  const token = JSON.parse(loginRes.body).token;
  
  // Use token in authenticated request
  const params = {
    headers: {
      'Authorization': `Bearer ${token}`,
    },
  };
  
  const res = http.get('https://api.example.com/profile', params);
  
  check(res, {
    'profile loaded': (r) => r.status === 200
  });
}

name: Performance Test

on: [push]

jobs:
  k6-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Run k6 test
        uses: grafana/k6-action@v0.3.0
        with:
          filename: tests/load-test.js
          
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: k6-results
          path: summary.json

// JMeter Aggregate Report Excerpt

Label              Samples  Average  Median  90%    95%    99%    Error%  Throughput
─────────────────────────────────────────────────────────────────────
GET /api/users     10000    245ms    198ms  421ms  534ms  892ms  0.23%   125.4/sec
POST /api/cart     8500     312ms    287ms  512ms  645ms  1.1s   0.41%   106.8/sec
GET /api/checkout  7200     1.2s     985ms  2.1s   2.8s   4.5s   1.87%   90.2/sec

// Analysis:
⚠️ ISSUES DETECTED:
1. Checkout endpoint: High response time (1.2s avg)
2. Large percentile gaps (median 985ms vs 99th 4.5s) → inconsistent
3. Error rate 1.87% exceeds 1% threshold
4. Lower throughput suggests bottleneck

// Step-by-Step Analysis Process

1. Identify Slow Endpoints
   → Look at response time by URL/transaction
   → Find which requests exceed SLA

2. Check Server Resources
   → CPU utilization (high = computation bottleneck)
   → Memory usage (growing = memory leak)
   → Disk I/O (high = database/file system)
   → Network bandwidth (saturated = data transfer issue)

3. Database Performance
   → Slow query log
   → Connection pool metrics
   → Query execution plans
   → Index usage statistics

4. Application Profiling
   → Method execution times
   → External API call duration
   → Cache hit/miss rates
   → Thread dumps (deadlocks)

5. Error Analysis
   → HTTP error codes distribution
   → Exception logs correlation
   → Error rate vs load relationship

Database Optimization:
✓ Add indexes on frequently queried columns
✓ Optimize slow queries (use EXPLAIN)
✓ Implement connection pooling
✓ Use read replicas for queries
✓ Add database caching (Redis, Memcached)

Application Layer:
✓ Enable HTTP caching (ETag, Cache-Control)
✓ Implement application-level caching
✓ Use async processing for heavy tasks
✓ Optimize serialization/deserialization
✓ Reduce payload size (compression, pagination)

Infrastructure:
✓ Horizontal scaling (add more servers)
✓ Vertical scaling (increase server resources)
✓ Configure auto-scaling
✓ Use CDN for static assets
✓ Optimize load balancer configuration

Code Level:
✓ Fix N+1 query problems
✓ Batch API calls
✓ Implement lazy loading
✓ Remove unnecessary computations
✓ Use efficient algorithms/data structures

Thread Group: "Black Friday Shoppers"
  Threads: 2000
  Ramp-up: 600s (10 minutes)
  Duration: 1800s (30 minutes)

  HTTP Request Defaults:
    Server: shop.example.com
    Protocol: https

  CSV Data Set: "users.csv"
    Variables: username,password,cardNumber

  Transaction Controller: "Browse Products"
    → GET / (Homepage)
    → Uniform Random Timer (3000-7000ms)
    → GET /search?q=${__Random(product1,product2,product3)}
    → JSON Extractor (extract productId)
    → Response Assertion (status 200)

  Transaction Controller: "Add to Cart"
    → GET /product/${productId}
    → Uniform Random Timer (10000-20000ms)
    → POST /cart/add
    → Duration Assertion (< 1000ms)

  Transaction Controller: "Checkout"
    → GET /cart
    → POST /checkout/initiate
    → POST /payment/process
    → Duration Assertion (< 5000ms)
    → Response Assertion (contains "success")

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

export const options = {
  stages: [
    { duration: '10m', target: 2000 },
    { duration: '30m', target: 2000 },
  ],
  thresholds: {
    'http_req_duration{name:checkout}': ['p(95)<5000'],
    'http_req_duration{name:search}': ['p(95)<1500'],
    'http_req_failed': ['rate<0.001'],
  },
};

export default function() {
  const baseUrl = 'https://shop.example.com';
  
  // Browse products
  http.get(`${baseUrl}/`);
  sleep(Math.random() * 4 + 3);
  
  const searchRes = http.get(
    `${baseUrl}/search?q=laptop`,
    { tags: { name: 'search' } }
  );
  
  const products = JSON.parse(searchRes.body).products;
  const productId = products[0].id;
  
  // Checkout
  http.post(
    `${baseUrl}/checkout/process`,
    JSON.stringify({ productId }),
    { tags: { name: 'checkout' } }
  );
}

val authSpike = scenario("Auth Spike Test")
  .exec(
    http("Login")
      .post("/api/auth/login")
      .body(StringBody("""{"user":"${user}","pass":"${pass}"}"""))
      .check(status.is(200))
      .check(jsonPath("$.token").saveAs("token"))
  )

setUp(
  authSpike.inject(
    nothingFor(10 seconds),
    atOnceUsers(5000),       // Sudden spike
    nothingFor(2 minutes),
    constantUsersPerSec(100) during(5 minutes) // Normal load
  )
).assertions(
  global.responseTime.max.lt(10000),
  global.successfulRequests.percent.gt(99)
)

Response Time Metrics:
→ Average: Mean of all requests
→ Median (50th): Middle value
→ 90th Percentile: 90% of requests faster than this
→ 95th Percentile: 95% of requests faster (common SLA)
→ 99th Percentile: 99% of requests faster
→ Max: Slowest request

Throughput Metrics:
→ TPS: Transactions Per Second
→ RPS: Requests Per Second
→ Hits/sec: Total HTTP requests per second

Error Metrics:
→ Error Rate: Percentage of failed requests
→ Error Types: HTTP 4xx, 5xx, timeouts, connection errors

Resource Metrics:
→ CPU: Processor utilization %
→ Memory: RAM usage and growth
→ Disk I/O: Read/write operations
→ Network: Bandwidth utilization

// Little's Law
Concurrent Users = Throughput × Response Time

// Example:
Throughput: 100 requests/second
Response Time: 3 seconds
Concurrent Users: 100 × 3 = 300 users

// Error Rate
Error Rate = (Failed Requests / Total Requests) × 100

// Throughput from Duration
TPS = Total Transactions / Test Duration (seconds)

// Ramp-up Calculation
Thread Start Interval = Ramp-up Period / Number of Threads