awesome-repositories.com
ब्लॉग
awesome-repositories.com

AI-संचालित खोज के साथ बेहतरीन ओपन-सोर्स रिपॉजिटरी खोजें।

एक्सप्लोर करेंक्यूरेटेड खोजेंओपन-सोर्स विकल्पसेल्फ-होस्टेड सॉफ्टवेयरब्लॉगसाइटमैप
प्रोजेक्टहमारे बारे मेंहम रैंकिंग कैसे करते हैंप्रेसMCP सर्वर
कानूनीगोपनीयताशर्तें
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
apache avatar

apache/jmeter

0
View on GitHub↗
9,233 स्टार्स·2,265 फोर्क्स·Java·apache-2.0·9 व्यूज़jmeter.apache.org↗

Jmeter

Apache JMeter is a Java-based performance testing tool and multi-protocol traffic simulator used to analyze the stability and scalability of servers and networks. It functions as a distributed load testing framework that coordinates remote worker nodes from a single controller to generate high volumes of concurrent traffic.

The project is distinguished by its ability to simulate traffic across diverse backend systems, including HTTP, JDBC, LDAP, JMS, FTP, and TCP. It provides a headless command-line interface for automated execution and a reporting system that transforms raw sample logs into analytical dashboards featuring APDEX scores and response time percentiles.

The framework covers a broad set of capabilities for test engineering, including browser traffic recording, data parameterization via external files, and response validation. It includes utilities for data extraction using JSONPath, XPath, and regular expressions, as well as traffic management tools for throughput throttling and connection emulation.

Extensibility is supported through a plugin-based architecture that allows for the development of custom samplers, GUI components, and the integration of custom Java code or scripting languages.

Features

  • Distributed Load Generation - Coordinates multiple remote worker nodes to generate massive traffic loads from a single controller.
  • Data Extraction - Parses information from structured or unstructured responses to correlate data between sequential network requests.
  • Distributed Testing Grids - Provides the infrastructure and coordination required to scale automated test execution across multiple remote nodes.
  • Multi-Protocol Load Testing - Executes performance tests across diverse communication protocols including HTTP, WebSockets, and JMS.
  • Master-Worker Coordination - Coordinates remote worker nodes via a central controller to generate high-volume traffic.
  • Third-Party Plugins - Loads third-party JAR files from specified directories to extend the tool with new samplers and GUI elements.
  • Plugin Architectures - Supports extending the framework's functionality by adding JAR files to the classpath without requiring a full system build.
  • Performance Test Design - Allows the design of complex performance tests via manual setup or by recording actual browser traffic.
  • Dynamic Response Correlation - Extracts values from server responses and passes them into subsequent requests to maintain session state.
  • Test Parameterization - Injects external values from CSV files or properties into samplers to simulate varied user credentials.
  • HTTP Load Testing - Simulates high volumes of concurrent web traffic to measure server stability and throughput.
  • HTTP Request Clients - Executes programmatic HTTP requests to web servers to validate backend services and performance.
  • Performance Analysis - Analyzes REST and SOAP service responses to identify performance bottlenecks and latency.
  • Performance Testing - Simulates heavy load on servers and networks to analyze stability across multiple protocols.
  • Load Testing Tools - Evaluates system stability and scalability by analyzing performance under heavy simulated user traffic.
  • Sampler Logic Extensions - Provides pluggable components and scripting integration to add custom sampling capabilities and data manipulation.
  • Performance Testing Frameworks - Provides a framework for measuring system scalability and stability through scripted network requests.
  • Virtual User Simulation - Simulates concurrent traffic by spawning multiple threads that execute scripted scenarios in parallel.
  • Request Simulators - Simulates requests via HTTP, JDBC, LDAP, JMS, FTP, and TCP to verify backend system performance.
  • Traffic Recorders - Captures HTTP and HTTPS traffic via a proxy to automatically generate testable request sequences.
  • Performance Monitoring Dashboards - Transforms raw sample logs into HTML dashboards featuring APDEX scores and response time percentiles.
  • XPath 2.0 Parsing - Supports the XPath 2.0 standard to parse XML namespaces and capture complex data points from responses.
  • JSONPath Extraction - Retrieves specific values from JSON responses using standard JSONPath syntax for data correlation.
  • XML Parsers - Queries XML files using XPath to retrieve matching nodes sequentially for use in tests.
  • Database Connectivity - Uses database drivers to execute queries and measure the response time of data layers.
  • Database Query Execution - Executes SQL statements against databases using connection pools to measure performance.
  • File-Based Data Import - Loads comma-separated values from external files to provide unique data for test iterations.
  • Web Data Extraction - Extracts data from HTML, CSS, and WML responses using configurable parser implementations.
  • Automated Test Execution - Provides a command-line interface to trigger and run performance test suites without a graphical user interface.
  • Dynamic Variable Evaluators - Resolves nested expressions and placeholders at runtime to inject parameterized data into requests.
  • Inter-Thread State Management - Implements global properties to communicate state and synchronize data between different concurrent threads and groups.
  • Headless Test CLIs - Provides a command-line interface for executing complex test plans without a graphical user interface.
  • Regular Expressions - Uses regular expressions to parse and extract specific strings from server responses or variables.
  • Traffic Throttling - Introduces variable pauses to maintain a specific target rate of samples per unit of time.
  • Database Stress Testing - Evaluates database performance and scalability by running concurrent JDBC queries and SQL statements.
  • Request Timeout Configurations - Sets maximum wait times for requests to ensure tests fail fast when servers are unresponsive.
  • Real-time Event Streams - Transmits performance metrics from execution threads to listeners for real-time reporting.
  • Custom Runtime Logic - Harnesses custom Java classes to implement specialized sampling logic and data collection routines.
  • Thread-Synchronized Execution - Blocks a specific number of threads and releases them simultaneously to create peak loads.
  • Random Data Generators - Produces random numbers, dates, and strings to simulate varied and realistic user input.
  • Test Scripting Engines - Embeds multiple language runtimes to allow custom logic and data manipulation during test execution.
  • Test Sequence Control - Enables controlling the test execution path by breaking loops or skipping iterations based on result status.
  • Sampler Interfaces - Standardizes the execution and measurement of diverse network protocols through a common sampler interface.
  • CSS Selector Engines - Employs CSS and jQuery-like selector engines to isolate specific elements or text from HTML pages.
  • Performance Reporting - Generates dynamic HTML dashboards featuring APDEX scores, response time percentiles, and throughput graphs.
  • Metric Time-Series Graphs - Produces time-series visualizations for specific sample variables found in logs using custom properties.
  • Execution Hierarchies - Organizes test logic as a nested structure of elements that define execution flow and configuration.
  • Test Report Exporters - Saves performance data and execution outcomes in CSV or XML formats for external reporting.
  • Remote Execution Controls - Provides a remote server via HTTP or Telnet to modify test properties and throughput during execution.
  • Performance Metric Exports - Streams real-time performance metrics and raw data to external time-series databases for deeper analysis.
  • Test Execution Management - Manages the execution of test elements using loops, conditional statements, and random selection.
  • User Behavior Pacing - Introduces pauses between requests using various distributions to simulate realistic user behavior.
  • Web Traffic Simulators - Replicates real user behavior by recording browser traffic via a proxy to create test plans.
  • Poisson Arrival Simulation - Produces a constant throughput of requests based on a Poisson distribution for realistic traffic simulation.
  • HTTP Cookie Managers - Automates the lifecycle of HTTP cookies to maintain session state across sequential requests.
  • Response Validation - Verifies that server responses match expected patterns, contain specific text, or adhere to size limits.
  • Core Distributions - The primary source code repository for the testing application.
  • Performance Testing - Standard open-source load testing tool.
  • टेस्टिंग फ्रेमवर्क्स - Feature-rich tool for load testing and performance analysis.

स्टार हिस्ट्री

apache/jmeter के लिए स्टार हिस्ट्री चार्टapache/jmeter के लिए स्टार हिस्ट्री चार्ट

AI सर्च

और अधिक बेहतरीन रिपॉजिटरी खोजें

अपनी ज़रूरत को सरल भाषा में बताएं — AI हजारों क्यूरेटेड ओपन-सोर्स प्रोजेक्ट्स को प्रासंगिकता के आधार पर रैंक करता है।

Start searching with AI

अक्सर पूछे जाने वाले प्रश्न

apache/jmeter क्या करता है?

Apache JMeter is a Java-based performance testing tool and multi-protocol traffic simulator used to analyze the stability and scalability of servers and networks. It functions as a distributed load testing framework that coordinates remote worker nodes from a single controller to generate high volumes of concurrent traffic.

apache/jmeter की मुख्य विशेषताएं क्या हैं?

apache/jmeter की मुख्य विशेषताएं हैं: Distributed Load Generation, Data Extraction, Distributed Testing Grids, Multi-Protocol Load Testing, Master-Worker Coordination, Third-Party Plugins, Plugin Architectures, Performance Test Design।

apache/jmeter के कुछ ओपन-सोर्स विकल्प क्या हैं?

apache/jmeter के ओपन-सोर्स विकल्पों में शामिल हैं: gatling/gatling — Gatling is a load testing framework and traffic generation engine used to measure response times and error rates under… loadimpact/k6 — k6 is a developer-centric load testing suite and command-line load generator designed for network performance… artilleryio/artillery — Artillery is a Node.js load testing tool and performance testing framework used to generate high-volume synthetic… tsenart/vegeta — Vegeta is an HTTP load testing tool and library designed to measure the performance and stability of web services. It… grafana/k6 — k6 is a performance testing framework used to measure the scalability and stability of network services and APIs. It… getanteon/anteon — Anteon is a distributed load testing platform and automated performance testing suite designed to simulate…

Jmeter के ओपन-सोर्स विकल्प

समान ओपन-सोर्स प्रोजेक्ट्स, जो Jmeter के साथ साझा की गई सुविधाओं के आधार पर रैंक किए गए हैं।
  • gatling/gatlinggatling का अवतार

    gatling/gatling

    6,923GitHub पर देखें↗

    Gatling is a load testing framework and traffic generation engine used to measure response times and error rates under heavy load. It functions as an as-code testing library, allowing users to define high-volume traffic simulations and performance tests through programming languages rather than graphical interfaces. The system enables multi-language load simulation and the ability to model concurrent user traffic to identify infrastructure bottlenecks and stability limits. It supports a test-as-code workflow, where version-controlled scripts are integrated into build pipelines as performance

    Scala
    GitHub पर देखें↗6,923
  • loadimpact/k6loadimpact का अवतार

    loadimpact/k6

    30,891GitHub पर देखें↗

    k6 is a developer-centric load testing suite and command-line load generator designed for network performance validation. It functions as a JavaScript load testing tool that utilizes a Go-based runtime engine to simulate concurrent user traffic and validate API responses across HTTP, gRPC, and WebSockets. The project distinguishes itself by using code rather than a graphical interface to define workload scenarios and performance thresholds. It features a pluggable protocol architecture and an extension ecosystem that allows for the addition of custom protocols and specialized testing capabili

    Go
    GitHub पर देखें↗30,891
  • artilleryio/artilleryA

    artilleryio/artillery

    9,003GitHub पर देखें↗

    Artillery is a Node.js load testing tool and performance testing framework used to generate high-volume synthetic traffic. It functions as a distributed load generator capable of spawning traffic from cloud infrastructure and Kubernetes clusters to simulate massive user loads. The project distinguishes itself through its ability to execute browser-based load tests using headless browsers to measure client-side rendering and real user journeys. It also serves as a protocol testing framework that validates multiple communication standards and real-time protocols through complex, multi-step tran

    JavaScript
    GitHub पर देखें↗9,003
  • tsenart/vegetatsenart का अवतार

    tsenart/vegeta

    25,070GitHub पर देखें↗

    Vegeta is an HTTP load testing tool and library designed to measure the performance and stability of web services. It functions as a command-line utility, a programmable package for integration into other applications, and a distributed load generator capable of splitting request rates across multiple machines. The tool is distinguished by its constant-rate request scheduler, which dispatches requests at a fixed frequency regardless of target response times. It employs lazy target streaming to maintain low memory usage during large tests and uses a binary-encoded storage format to minimize di

    Gobenchmarkinggohttp
    GitHub पर देखें↗25,070
  • Jmeter के सभी 30 विकल्प देखें→