jmeter

# Download từ https://jmeter.apache.org/download_jmeter.cgi
# Giải nén và chạy
cd apache-jmeter-5.6.3/bin
 
# Windows
jmeter.bat
 
# Linux/Mac
./jmeter.sh

# File: bin/jmeter.bat hoặc bin/jmeter
# Tăng heap cho JMeter khi chạy test lớn (>1000 threads)
HEAP="-Xms2g -Xmx4g"

@RestController
@RequestMapping("/api/v1/products")
@RequiredArgsConstructor
public class ProductController {
 
   private final ProductService productService;
 
   @GetMapping
   public ResponseEntity<APIResponse<Page<ProductDTO>>> list(
           @RequestParam(defaultValue = "0") int page,
           @RequestParam(defaultValue = "20") int size,
           @RequestParam(required = false) String keyword) {
       Page<ProductDTO> result = productService.search(keyword, PageRequest.of(page, size));
       return ResponseEntity.ok(APIResponse.success(result));
   }
 
   @GetMapping("/{id}")
   public ResponseEntity<APIResponse<ProductDTO>> getById(@PathVariable UUID id) {
       return ResponseEntity.ok(APIResponse.success(productService.getById(id)));
   }
 
   @PostMapping
   public ResponseEntity<APIResponse<ProductDTO>> create(
           @Valid @RequestBody CreateProductRequest request) {
       ProductDTO created = productService.create(request);
       return ResponseEntity.status(HttpStatus.CREATED).body(APIResponse.success(created));
   }
 
   @PutMapping("/{id}")
   public ResponseEntity<APIResponse<ProductDTO>> update(
           @PathVariable UUID id,
           @Valid @RequestBody UpdateProductRequest request) {
       return ResponseEntity.ok(APIResponse.success(productService.update(id, request)));
   }
 
   @DeleteMapping("/{id}")
   @ResponseStatus(HttpStatus.NO_CONTENT)
   public void delete(@PathVariable UUID id) {
       productService.delete(id);
   }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
   @Bean
   public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       return http
           .csrf(AbstractHttpConfigurer::disable)
           .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
           .oauth2ResourceServer(oauth -> oauth.jwt(Customizer.withDefaults()))
           .authorizeHttpRequests(auth -> auth
               .requestMatchers("/actuator/**").permitAll()
               .anyRequest().authenticated())
           .build();
   }
}

username,password
user001,Pass@123
user002,Pass@123
user003,Pass@123
...
user100,Pass@123

# Mở GUI
./bin/jmeter.bat
# Tạo test plan → Save as .jmx file
# KHÔNG chạy test thực sự ở GUI — tốn resource, kết quả không chính xác

# Chạy test từ command line
jmeter -n -t test-plan.jmx -l results.jtl -e -o report-output/
 
# Giải thích:
# -n : non-GUI mode
# -t : test plan file (.jmx)
# -l : log results file (.jtl)
# -e : generate HTML report sau khi test xong
# -o : output folder cho HTML report
 
# Với custom properties
jmeter -n -t test-plan.jmx -l results.jtl \
 -Jthreads=200 \
 -Jrampup=60 \
 -Jduration=300 \
 -Jhost=api.staging.vpbank.com \
 -Jport=443

# Trên mỗi Slave machine — chạy JMeter server
jmeter-server -Djava.rmi.server.hostname=192.168.1.101
 
# Trên Master — file jmeter.properties
remote_hosts=192.168.1.101,192.168.1.102,192.168.1.103
 
# Chạy distributed test từ Master
jmeter -n -t test-plan.jmx -l results.jtl -R 192.168.1.101,192.168.1.102,192.168.1.103

# application.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 30 # Tăng theo số concurrent request
      minimum-idle: 10
      connection-timeout: 20000 # 20s
      idle-timeout: 300000 # 5 phút
      max-lifetime: 1200000 # 20 phút
      leak-detection-threshold: 60000 # Log warning nếu connection giữ > 60s

server:
  tomcat:
    threads:
      max: 200 # Max worker threads (default: 200)
      min-spare: 20 # Min idle threads
    max-connections: 8192
    accept-count: 100 # Queue size khi tất cả threads bận
    connection-timeout: 20000

@Service
@RequiredArgsConstructor
public class ProductService {
 
   private final ProductRepository repo;
   private final RedisTemplate<String, ProductDTO> redisTemplate;
 
   @Cacheable(value = "products", key = "#id", unless = "#result == null")
   public ProductDTO getById(UUID id) {
       return repo.findById(id)
           .map(this::toDTO)
           .orElseThrow(() -> new EntityNotFoundException("Product not found: " + id));
   }
 
   @CacheEvict(value = "products", key = "#id")
   public ProductDTO update(UUID id, UpdateProductRequest request) {
       // ... update logic
   }
}

@Configuration
@EnableAsync
public class AsyncConfig {
 
   @Bean("taskExecutor")
   public Executor taskExecutor() {
       ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
       executor.setCorePoolSize(10);
       executor.setMaxPoolSize(30);
       executor.setQueueCapacity(500);
       executor.setThreadNamePrefix("async-");
       executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
       executor.initialize();
       return executor;
   }
}
 
// Non-critical work (audit log, notification) chạy async
@Async("taskExecutor")
public void logActivity(ActivityEvent event) {
   activityRepository.save(event);
}

# Cho production với Spring Boot
JAVA_OPTS="-Xms2g -Xmx2g \
 -XX:+UseG1GC \
 -XX:MaxGCPauseMillis=200 \
 -XX:+UseStringDeduplication \
 -XX:+OptimizeStringConcat \
 -Djava.security.egd=file:/dev/./urandom"

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,prometheus,metrics
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: ${spring.application.name}

# Thêm Backend Listener trong JMeter:
# Type: org.apache.jmeter.visualizers.backend.influxdb.InfluxdbBackendListenerClient
# influxdbUrl: http://influxdb:8086/write?db=jmeter
# application: csp-product-api
# measurement: jmeter

# Download từ https://jmeter-plugins.org/install/Install/
# Copy jmeter-plugins-manager.jar vào lib/ext/
# Restart JMeter → Menu Options → Plugins Manager

// JSR223 PreProcessor (Groovy)
import groovy.json.JsonOutput
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
 
def now = LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME)
def requestBody = [
   name: "Product-${UUID.randomUUID().toString().take(8)}",
   code: "PRD-${vars.get('__threadNum')}-${System.currentTimeMillis()}",
   price: new Random().nextInt(9000) + 1000,
   category: ["ELECTRONICS", "CLOTHING", "FOOD", "BOOKS"][new Random().nextInt(4)],
   metadata: [
       createdAt: now,
       source: "jmeter-load-test",
       batchId: vars.get("BATCH_ID") ?: "batch-001"
   ]
]
 
vars.put("requestBody", JsonOutput.toJson(requestBody))

// JSR223 PostProcessor (Groovy)
import groovy.json.JsonSlurper
 
def response = new JsonSlurper().parseText(prev.getResponseDataAsString())
 
if (response.data?.id) {
   vars.put("created_product_id", response.data.id.toString())
   log.info("Created product: ${response.data.id}")
} else {
   log.error("Failed to create product. Response: ${prev.getResponseDataAsString()}")
   prev.setSuccessful(false)
   prev.setResponseMessage("Product creation failed - no ID returned")
}
 
// Lưu metrics custom
def responseTime = prev.getTime()
if (responseTime > 2000) {
   log.warn("SLOW REQUEST: ${prev.getSampleLabel()} took ${responseTime}ms")
}

// JSR223 Assertion (Groovy)
import groovy.json.JsonSlurper
 
def response = new JsonSlurper().parseText(prev.getResponseDataAsString())
 
// Validate business rules
if (response.data?.price != null && response.data.price <= 0) {
   AssertionResult.setFailure(true)
   AssertionResult.setFailureMessage("Product price must be positive, got: ${response.data.price}")
}
 
if (response.data?.name?.length() > 255) {
   AssertionResult.setFailure(true)
   AssertionResult.setFailureMessage("Product name exceeds 255 chars")
}

# .gitlab-ci.yml
load-test:
  stage: performance
  image: justb4/jmeter:5.6.3
  variables:
    TARGET_HOST: 'api.staging.internal'
    TARGET_PORT: '443'
    THREADS: '200'
    DURATION: '300'
  script:
    - mkdir -p results
    - jmeter -n
      -t tests/load-test-plan.jmx
      -l results/results.jtl
      -e -o results/report/
      -Jhost=${TARGET_HOST}
      -Jport=${TARGET_PORT}
      -Jthreads=${THREADS}
      -Jduration=${DURATION}
    # Fail pipeline nếu error rate > 2% hoặc P95 > 2000ms
    - python3 scripts/check-results.py results/results.jtl
      --max-error-rate 2
      --max-p95 2000
  artifacts:
    paths:
      - results/report/
    when: always
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule" # Chạy theo schedule
    - if: $CI_COMMIT_BRANCH == "main"
      when: manual

# scripts/check-results.py
import csv
import sys
import argparse
 
def analyze_results(jtl_file, max_error_rate, max_p95):
   errors = 0
   total = 0
   response_times = []
 
   with open(jtl_file, 'r') as f:
       reader = csv.DictReader(f)
       for row in reader:
           total += 1
           if row['success'] == 'false':
               errors += 1
           response_times.append(int(row['elapsed']))
 
   error_rate = (errors / total) * 100 if total > 0 else 0
   response_times.sort()
   p95_index = int(len(response_times) * 0.95)
   p95 = response_times[p95_index] if response_times else 0
 
   print(f"Total requests: {total}")
   print(f"Error rate: {error_rate:.2f}%")
   print(f"P95 response time: {p95}ms")
 
   if error_rate > max_error_rate:
       print(f"FAIL: Error rate {error_rate:.2f}% exceeds threshold {max_error_rate}%")
       sys.exit(1)
   if p95 > max_p95:
       print(f"FAIL: P95 {p95}ms exceeds threshold {max_p95}ms")
       sys.exit(1)
 
   print("PASS: All thresholds met")
 
if __name__ == "__main__":
   parser = argparse.ArgumentParser()
   parser.add_argument("jtl_file")
   parser.add_argument("--max-error-rate", type=float, default=2.0)
   parser.add_argument("--max-p95", type=int, default=2000)
   args = parser.parse_args()
   analyze_results(args.jtl_file, args.max_error_rate, args.max_p95)