Load Ammeter - HTTP Client & Load Testing Tool for VS Code

A professional VS Code extension that combines HTTP client capabilities with comprehensive load testing features, enabling developers to build requests, execute performance tests, and analyze metrics directly within their IDE.

Overview

Load Ammeter brings the power of Postman and Apache JMeter directly into Visual Studio Code. Test your APIs, run load tests, and analyze performance metrics without leaving your development environment.

Key Benefits:

• 🎯 Build and test HTTP requests with an intuitive interface
• ⚡ Execute load tests with configurable concurrent users and workers
• 📊 Monitor real-time metrics and performance analytics
• 💾 Organize requests in collections for reusability
• 📈 Export detailed reports in multiple formats

---

Getting Started

Installation

1. Open VS Code
2. Press Ctrl+Shift+X (Windows/Linux) or Cmd+Shift+X (Mac) to open Extensions
3. Search for "Load Ammeter"
4. Click Install

Quick Start

1. Open Load Ammeter: Click the Load Ammeter icon in the Activity Bar (left sidebar)
2. Create a Request: Enter a URL and select an HTTP method
3. Send Request: Click the "Send" button to test your API
4. Run Load Test: Click "Load Test" to execute performance testing

---

Features

🌐 HTTP Request Builder

Build and test HTTP requests with a Postman-like interface:

• All HTTP Methods: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
• Request Configuration:
  • Query parameters with enable/disable toggles
  • Custom headers management
  • Multiple body types: JSON, Raw, Form-data, URL-encoded
  • Authentication: Basic, Bearer Token, API Key
• Advanced Editor: Monaco editor with syntax highlighting for JSON

Example Request:

POST https://api.example.com/users
Headers:
  Content-Type: application/json
  Authorization: Bearer {{token}}
Body:
{
  "name": "{{randomName}}",
  "email": "{{randomEmail}}",
  "timestamp": {{timestamp}}
}

⚡ Load Testing Engine

Execute comprehensive load tests with configurable parameters:

Parameter	Description	Default	Range
Concurrent Users	Number of virtual users	10	1-10000
Max Workers	Parallel worker threads	4	1-16
Requests per User	Requests each user executes	100	1-100000
Timeout	Request timeout (ms)	30000	1000-300000
Delay	Delay between requests (ms)	0	0-60000
Ramp-up	Gradual user increase (ms)	0	0-300000

Advanced Options:

• HTTP/1.1 or HTTP/2 protocol selection
• Connection keep-alive and pooling
• Stop on first failure
• Retry mechanisms with configurable delays
• Infinite mode for continuous testing

📊 Real-Time Analytics

Monitor your load tests with live metrics:

• Performance Metrics:

  • Total requests executed
  • Success rate percentage
  • Failed requests count
  • Average response time
  • Min/Max response times
  • Requests per second

• Percentile Analysis:

  • P50 (Median)
  • P90 (90th percentile)
  • P95 (95th percentile)
  • P99 (99th percentile)

• Visual Charts:

  • Response time trend line chart
  • Success vs failure pie chart
  • Status code distribution
  • Real-time metric updates

🔄 Dynamic Variables

Use dynamic variables to generate unique data for each request:

Variable	Description	Example Output
{{timestamp}}	Current Unix timestamp	1704067200
{{uuid}}	Random UUID v4	550e8400-e29b-41d4-a716-446655440000
{{randomNumber}}	Random number	7342
{{randomEmail}}	Random email address	user7342@example.com
{{randomPhone}}	Random phone number	+1-555-0123
{{randomName}}	Random full name	John Smith
{{workerId}}	Current worker ID	3
{{requestNumber}}	Current request number	156

Usage Example:

{
  "userId": "{{uuid}}",
  "email": "user{{randomNumber}}@test.com",
  "createdAt": {{timestamp}},
  "phone": "{{randomPhone}}"
}

📁 Collections Management

Organize and reuse your requests efficiently:

• Create Collections: Group related requests together
• Folder Structure: Organize requests in nested folders
• Import/Export: Share collections as JSON files
• Duplicate Requests: Clone existing requests for quick modifications
• Environment Variables: Define variables per environment (Dev, Staging, Production)

📄 Export Reports

Export test results in multiple formats for analysis and reporting:

• CSV: Comma-separated values for Excel/Google Sheets
• XLSX: Native Excel format with formatting
• JSON: Raw data for programmatic processing
• HTML: Formatted web report with charts
• PDF: Professional report format (requires additional setup)

Reports include:

• Request/response details
• Response times and status codes
• Success/failure statistics
• Percentile metrics
• Timestamp information

---

Usage Guide

1. Building Your First Request

Step-by-step:

1. Click the Load Ammeter icon in the Activity Bar
2. In the request editor:
   • Enter a Request Name (e.g., "Get Users")
   • Enter the URL (e.g., https://jsonplaceholder.typicode.com/users)
   • Select HTTP Method (e.g., GET)
3. Click Send to execute the request

Adding Parameters:

• Navigate to the Params tab
• Click Add Row
• Enter key-value pairs (e.g., page=1, limit=10)

Adding Headers:

• Navigate to the Headers tab
• Click Add Row or use quick-add buttons for common headers
• Enter header name and value (e.g., Authorization: Bearer token123)

Configuring Body:

• Navigate to the Body tab
• Select body type: JSON, Raw, Form-data, or URL-encoded
• Enter your request body in the Monaco editor

2. Running a Load Test

Basic Load Test:

1. Configure your request as described above
2. Navigate to the Load Config tab
3. Set your test parameters:
   • Concurrent Users: 50
   • Max Workers: 4
   • Requests per User: 100
4. Click Load Test button
5. Monitor real-time metrics in the right panel

Advanced Load Test:

1. In the Load Config tab, expand Advanced Options
2. Configure:
   • HTTP Version: Select HTTP/2 for better performance
   • Keep-Alive: Enable for connection reuse
   • Ramp-up: Set to 10000ms to gradually increase load
   • Retry Count: Set to 3 for automatic retries
3. Click Load Test to start
4. Click Stop Test to terminate early if needed

3. Analyzing Results

Real-Time Monitoring:

• Watch the Live Metrics panel on the right
• Observe response time trends in the line chart
• Check success/failure distribution in the pie chart
• Monitor percentile metrics (P50, P90, P95, P99)

Detailed Results:

1. Navigate to the Results tab after test completion
2. Review the detailed table with:
   • Request number and timestamp
   • HTTP method and URL
   • Status code and response time
   • Success/failure status
3. Use filters to show only successful or failed requests
4. Search for specific URLs or status codes

Exporting Results:

1. Click the Export button in the Results tab
2. Select format: CSV, XLSX, JSON, HTML, or PDF
3. Choose save location
4. Reports are auto-numbered: report_001.csv, report_002.csv, etc.

4. Managing Collections

Creating a Collection:

1. Navigate to the Collections tab
2. Click New Collection
3. Enter collection name (e.g., "User API Tests")
4. Click Create

Adding Requests to Collections:

1. Configure your request in the Request Editor
2. Click the Save icon (💾) next to the request name
3. Select the target collection
4. Request is saved and can be loaded later

Importing/Exporting Collections:

• Export: Right-click collection → Export → Choose location
• Import: Click Import button → Select JSON file

5. Using Environment Variables

Setting Up Environments:

1. Navigate to the Environments tab
2. Click New Environment
3. Enter environment name (e.g., "Development")
4. Add variables:
   • Key: baseUrl, Value: https://dev-api.example.com
   • Key: apiKey, Value: dev_key_12345
5. Click Save

Using Variables in Requests:

• In URL field: {{baseUrl}}/users
• In Headers: X-API-Key: {{apiKey}}
• In Body: {"token": "{{apiKey}}"}

Switching Environments:

• Select environment from dropdown in Environments tab
• All requests will use the selected environment's variables

---

Configuration Reference

Load Test Settings

{
  "concurrentUsers": 10, // Number of virtual users
  "maxParallelWorkers": 4, // Worker threads (1-16)
  "requestsPerUser": 100, // Requests per user
  "timeout": 30000, // Request timeout (ms)
  "delayBetweenRequests": 0, // Delay between requests (ms)
  "rampUpDuration": 0, // Gradual load increase (ms)
  "retryCount": 0, // Failed request retries
  "retryDelay": 1000, // Delay before retry (ms)
  "httpVersion": "1.1", // HTTP version (1.1 or 2)
  "keepAlive": true, // Connection reuse
  "stopOnFailure": false, // Stop on first error
  "infiniteMode": false, // Run until stopped
  "autoSaveReport": false // Auto-save results
}

Request Configuration

{
  "name": "Create User",
  "method": "POST",
  "url": "https://api.example.com/users",
  "params": [{ "key": "version", "value": "v1", "enabled": true }],
  "headers": [
    { "key": "Content-Type", "value": "application/json", "enabled": true },
    { "key": "Authorization", "value": "Bearer {{token}}", "enabled": true }
  ],
  "body": {
    "type": "json",
    "content": "{\"name\": \"{{randomName}}\", \"email\": \"{{randomEmail}}\"}"
  },
  "auth": {
    "type": "bearer",
    "token": "your_token_here"
  }
}

---

Best Practices

Load Testing Guidelines

1. Start Small: Begin with 10 users and gradually increase
2. Use Ramp-up: Set ramp-up duration to avoid sudden spikes
3. Monitor Resources: Watch CPU and memory usage during tests
4. Set Realistic Timeouts: Match production timeout values
5. Use Keep-Alive: Enable for better performance and realistic testing
6. Test in Stages: Run short tests first, then increase duration

Performance Optimization

• Worker Threads: Use 4-8 workers for optimal performance
• Connection Pooling: Enable keep-alive for connection reuse
• Batch Requests: Use multiple requests per user instead of many users
• Delay Configuration: Add delays to simulate real user behavior

Security Considerations

• Never Commit Tokens: Use environment variables for sensitive data
• Rotate API Keys: Change keys regularly
• Use HTTPS: Always test against secure endpoints
• Limit Test Scope: Don't overload production servers

---

Troubleshooting

Common Issues

Extension Not Appearing:

• Reload VS Code window: Ctrl+Shift+P → "Reload Window"
• Check if extension is enabled in Extensions view
• Verify VS Code version is 1.115.0 or higher

Load Test Not Starting:

• Check if URL is valid and accessible
• Verify network connectivity
• Ensure worker count is between 1-16
• Check VS Code console for error messages

High Memory Usage:

• Reduce concurrent users
• Decrease requests per user
• Lower worker thread count
• Enable auto-save report to free memory

Timeout Errors:

• Increase timeout value in Load Config
• Check server response time
• Verify network stability
• Reduce concurrent load

---

Keyboard Shortcuts

Action	Windows/Linux	Mac
Open Command Palette	Ctrl+Shift+P	Cmd+Shift+P
Open Extensions	Ctrl+Shift+X	Cmd+Shift+X
Reload Window	Ctrl+R	Cmd+R
Toggle Sidebar	Ctrl+B	Cmd+B

---

Support & Resources

Documentation

• GitHub Repository
• Issue Tracker
• Discussions

Getting Help

• Report bugs via GitHub Issues
• Request features via GitHub Discussions
• Check existing issues before creating new ones

Contributing

Contributions are welcome! Please read the contributing guidelines in the repository.

---

Roadmap

Upcoming Features:

• WebSocket protocol support
• GraphQL request builder
• Test scenarios and workflows
• Response validation and assertions
• Mock server integration
• Team collaboration features
• Cloud synchronization
• CI/CD pipeline integration

---

License

Proprietary License - Copyright (c) 2024 Tushar Gour. All rights reserved.

See LICENSE for complete terms.

---

Acknowledgments

Inspired by industry-standard tools including Postman and Apache JMeter. Built for the developer community with a focus on performance testing and API development workflows.

Load Ammeter - Professional HTTP Client & Load Testing for VS Code

---

Version: 1.0.0 | Publisher: TusharGour | Category: Testing