Forem: NaveenKumar Namachivayam ⚡

Proof of Humanity™

NaveenKumar Namachivayam ⚡ — Thu, 02 Apr 2026 16:56:37 +0000

This is a submission for the DEV April Fools Challenge

What I Built

To prove you're human, you must assemble Flätpack furniture.
One step is irrelevant. Robots cannot detect irony.

Demo

https://kilo-challenge-8914.d.kiloapps.io/

Code

https://github.com/QAInsights/kilo-challenge

🛠️ How I Built It

I approached this project the way I tackle any complex system: break it down, understand the constraints, and build upward with tight feedback loops. Instead of jumping straight into coding, I started by mapping the experience I wanted users to have. From there, every technical decision flowed naturally.

🔍 1. Defining the Core Problem

Before writing a single line of code, I clarified the “why.” What should this tool feel like? What friction should it remove? What would make someone say, “Oh, that’s clever”?

This early framing helped me avoid feature creep and stay anchored to a crisp user experience.

🧩 2. Designing the Architecture

Once the problem was clear, I sketched the system architecture—data flow, state transitions, and the boundaries between components. I treated it like a mini system‑design exercise:

What should run locally vs. remotely
How to keep the interface responsive
How to ensure the tool remains extensible

This step saved me hours later because every component had a clear responsibility.

⚙️ 3. Building the Core Logic

With the architecture locked in, I implemented the core functionality. I built it incrementally, validating each piece before moving on. This iterative approach made debugging almost trivial and kept the project moving smoothly.

🎨 4. Crafting the User Experience

A tool is only as good as how it feels to use. I refined the UI/UX with small but meaningful touches:

Clear feedback loops
Minimal cognitive load
Fast, predictable interactions

I wanted the tool to feel like something I would enjoy using every day.

🧪 5. Testing Like a User, Not a Developer

I tested the project in real‑world scenarios—switching contexts, trying edge cases, and intentionally breaking things. This surfaced subtle issues that wouldn’t appear in a controlled environment.

🚀 6. Polishing and Shipping

Once the core was solid, I focused on polish:

Cleaned up the codebase
Improved performance
Added small quality‑of‑life improvements
Wrote documentation that future‑me would appreciate

Shipping wasn’t the end—it was the beginning of iteration.

If you want, I can also help you write the “What I Learned”, “Challenges I Faced”, or “Future Improvements” sections so your post looks complete and competition‑ready.

Prize Category

HTCPCP IYKYK

GitHub Copilot CLI Challenge: bt: Modern BLE CLI Tool

NaveenKumar Namachivayam ⚡ — Sun, 15 Feb 2026 21:43:47 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

There is no clean, simple, cross‑platform, developer‑friendly BLE CLI exists today. Linux has bluetoothctl, macOS has no official CLI, and Windows exposes only low‑level PowerShell APIs.

Developers working with BLE devices — especially ESP32‑based prototypes — lack a simple, unified, ergonomic CLI. My goal is to create a minimal, ergonomic, script‑friendly CLI for scanning, connecting, and interacting with BLE devices.

📝 Repo: https://github.com/QAInsights/bt

Demo

My Experience with GitHub Copilot CLI

bt was built using the copilot which acted as a copilot for this project. It helped me in brainstorming, planning, rapid prototyping using natural language processing even with my typos :)

🤖 copilot helped in no context switching, focused development, acting as a pair programmer, testing, and more.

As a beginner in Bluetooth modules, it helped in navigating the docs, debugging, beautifying the output, and testing it. Without leaving the ide , it helped in polishing the whole project.

Here is how it started:

and here is how it ended:

Repo: https://github.com/QAInsights/bt

Kan [கண்] is an intelligent eye health monitoring application

NaveenKumar Namachivayam ⚡ — Mon, 20 Oct 2025 16:47:08 +0000

I have just submitted my entry to https://nokeyboardsallowed.dev/ hackathon.

Protect your vision in the digital age. Kan [கண்] is an intelligent eye health monitoring application that tracks your blink rate in real-time, provides health insights, and helps prevent digital eye strain through continuous background monitoring.
Built using Goose.

Introducing a Lightweight Apache JMeter Docker Image: Efficient Load Testing Made Simple

NaveenKumar Namachivayam ⚡ — Tue, 18 Mar 2025 13:52:26 +0000

Are you looking for a lean, secure, and versatile Docker image for Apache JMeter to streamline your load testing workflows? Look no further! Today, I’m excited to share a new Dockerfile I’ve crafted that delivers a lightweight Apache JMeter image without compromising on functionality. Whether you’re a developer, DevOps engineer, or QA professional, this image is designed to make your performance testing faster, easier, and more efficient.

Why This JMeter Docker Image Stands Out

This isn’t your average JMeter setup. Here’s what makes this Docker image special:

Small and Secure Base: Built on Alpine Linux, known for its tiny footprint and security-first design.
Powered by Liberica JDK: Uses bellsoft/liberica-openjdk-alpine, a free, open-source Java runtime optimized for modern deployments.
Full JMeter Functionality: Includes Apache JMeter for robust load testing, plus a handy script to install plugins as needed.
Non-Root Execution: Runs as the jmeter user for enhanced security—no unnecessary root privileges here.
Multi-Architecture Ready: Supports both amd64 (x86_64) and arm64 platforms, so it works seamlessly on everything from Intel-based servers to Apple M1/M2/M3 chips, AWS Graviton, or even a Raspberry Pi 4.
Optimized Size: Thanks to multi-stage builds, the image is slim—151.78 MB compressed and 209.71 MB uncompressed.

This combination of features ensures you get a lightweight, secure, and flexible JMeter environment that’s ready to tackle your testing needs.

Getting Started: Basic Usage

Building and running the image is a breeze. Here’s how to get going:

Build the ImageIn the directory containing the Dockerfile, run:

docker build -t my-jmeter-image .

This creates an image tagged as my-jmeter-image.

Run JMeter

To execute a test, mount your test directory and specify your .jmx file:

docker run -v /path/to/your/test:/tests my-jmeter-image /tests/your-test.jmx

Replace /path/to/your/test with the local path to your test files and your-test.jmx with your test script’s filename. Done!

Multi-Architecture Support: Flexibility Across Platforms

One of the standout features of this image is its multi-architecture support. Whether you’re running on a traditional x86_64 machine or an ARM64 device like an Apple Silicon Mac or AWS Graviton instance, this image has you covered.

To build a multi-architecture image, use the provided build-multiarch.sh script:

# Make it executable
chmod +x build-multiarch.sh

# Check options
./build-multiarch.sh --help

# Build and push to your registry
./build-multiarch.sh --name jmeter --tag 5.6.3 --registry your-registry/ --push

The script is packed with options:

-n, --name: Set the image name (e.g., jmeter).
-t, --tag: Specify a version tag (e.g., 5.6.3).
-r, --registry: Define your Docker registry.
--push: Push the image to your registry after building.

This makes it easy to deploy JMeter across diverse environments without worrying about compatibility.

Advanced Usage: Customize Your Setup

Installing JMeter Plugins

Need specific plugins for your tests? You can add them directly in the Dockerfile. Just tweak the JMETER_PLUGINS argument with a comma-separated list:

ARG JMETER_PLUGINS="jpgc-udp=0.4,jpgc-dummy"

Want a specific version? Use =version-number. Otherwise, it’ll grab the latest.

Keeping It Lean

The image stays lightweight thanks to some clever optimizations:

Multi-Stage Builds: Dependencies are separated from the runtime, reducing bloat.
File Cleanup: Strips out unnecessary docs and Windows batch files.
Cache Management: Clears temporary files and package caches.
Minimal Plugins: Only what you need, nothing more.

These steps ensure you’re not hauling around extra weight, making your CI/CD pipelines or local runs faster.

Why Size Matters

At just 151.78 MB compressed, this image is significantly smaller than many JMeter setups, which often balloon past 500 MB. A smaller image means quicker downloads, faster deployments, and less resource overhead—perfect for scaling tests in the cloud or running locally on constrained hardware.

This project is open to contributions. Have an idea to make it even better? Found a bug? Feel free to submit a Pull Request on the repository. Let’s build something awesome together!

Final Thoughts

This lightweight Apache JMeter Docker image is all about efficiency, security, and flexibility. Whether you’re load testing a web app, API, or microservice, it’s got the tools you need in a package that won’t weigh you down. Give it a spin, tweak it to your liking, and let me know how it works for you!

Happy testing!

Introducing Feather Wand: Your AI-Powered Companion for JMeter

NaveenKumar Namachivayam ⚡ — Tue, 04 Mar 2025 19:00:00 +0000

Imagine having an intelligent assistant right inside JMeter, ready to help you craft, optimize, and troubleshoot your test plans with ease. That’s exactly what Feather Wand, a new JMeter plugin, brings to the table—a sprinkle of AI magic to transform your performance testing experience. Let’s dive into what makes this tool special, how it works, and why it might just become your go-to JMeter sidekick—especially for performance test engineers.

The Story Behind the Name

Before we get technical, a quick nod to the whimsical origin of "Feather Wand." The name comes from my kids, who were inspired by an episode of Bluey—the charming animated show. In that episode, a simple feather turns into a magical wand, making ordinary things extraordinary (and hilariously heavy). Much like that feather, this plugin aims to take your everyday JMeter tasks and elevate them with a touch of AI-powered brilliance. Who says tech can’t have a playful side?

What Does Feather Wand Do?

Feather Wand seamlessly integrates an AI chatbot into JMeter, powered by Anthropic’s Claude API. Whether you’re a JMeter newbie or a seasoned performance test engineer, this plugin is designed to make your life easier. Here’s what it offers:

Chat with AI in JMeter: Ask questions, get advice, and brainstorm solutions directly within the JMeter interface.
Smart Suggestions: Need help picking the right JMeter elements? The AI can recommend options tailored to your goals.
JMeter Expertise On Demand: From functionality deep-dives to best practices, Feather Wand has answers.
@this Command: Highlight an element in your test plan and type @this to get detailed, context-specific insights about it.
Customizable AI: Tweak how the AI behaves via configuration properties to suit your workflow.

Think of it as having a virtual mentor who’s always ready to lend a hand—or a wand.

Why Performance Test Engineers Need This

Performance testing is a critical discipline, but it’s often riddled with complexity and tight deadlines. Feather Wand steps in to streamline your workflow and boost productivity. Here are some real-world use cases where it shines for performance test engineers:

1. Brainstorming with the AI Chat Interface

Stuck on how to simulate a tricky user journey, like a multi-step checkout process under heavy load? Open the Feather Wand chat and ask, “How should I structure a test plan for an e-commerce checkout flow?” The AI might suggest a mix of Thread Groups, HTTP Samplers, and Timers—complete with a logical sequence—all without leaving JMeter. It’s like having a collaborative teammate on speed dial, perfect for rapid prototyping or tackling unfamiliar scenarios.

2. Adding Elements with One Click

Building a test plan from scratch can feel tedious—clicking through menus to add samplers, assertions, or listeners. With Feather Wand, you can say, “Add an HTTP Request Sampler for a login endpoint,” and the AI can guide you to insert it with a single click (or suggest the exact configuration). This cuts down repetitive setup time, letting you focus on crafting the test logic instead of wrestling with the UI.

3. Generating Groovy Snippets for Custom Logic

JMeter’s JSR223 Sampler with Groovy is a powerhouse for custom scripting, but writing code under pressure can slow you down. Need to generate a random user ID or manipulate response data? Ask Feather Wand, “Generate a Groovy snippet to create a random 8-digit user ID.” You’ll get a ready-to-use script like vars.put("userId", String.valueOf((int)(Math.random() * 100000000))), saving you from syntax headaches and speeding up your test development.

4. Optimizing Load Scenarios

Designing realistic load tests is an art. Suppose you’re simulating 10,000 users hitting an API during a flash sale. Ask Feather Wand, “How can I optimize my test for peak load?” It might recommend adjusting ramp-up periods, adding a Constant Throughput Timer, or distributing load across multiple Thread Groups—tailored advice that helps you fine-tune performance without guesswork.

5. Troubleshooting Performance Bottlenecks

Post-test analysis can be daunting when response times spike unexpectedly. Select a slow sampler and type, “What might be causing delays here with

@this Feather Wand could suggest adding a Debug Sampler, tweaking timeouts, or checking for unhandled dynamic data—giving you a clear starting point to dig deeper and resolve the issue.

These use cases show how Feather Wand empowers performance test engineers to work smarter, not harder, turning JMeter into a more intuitive and efficient tool.

A Word of Caution: Best Practices & Disclaimer

AI is powerful, but it’s not infallible. Here are some tips to keep in mind while using Feather Wand:

Double-Check Everything: The AI might occasionally miss the mark. Verify its suggestions, especially for production-critical tests.
Backup, Backup, Backup: Save your test plans before applying major AI-driven changes—just in case.
Test Before You Trust: Run AI-suggested tweaks in a safe environment first to ensure they work as expected.
Watch Performance: Some configurations might affect resource usage, so keep an eye on your system.
Stay Secure: Avoid sharing sensitive data (like credentials) in your AI chats.
Mind the Costs: The plugin uses the Claude API, which incurs token-based charges. Heavy use will reflect on your Anthropic billing.

Feather Wand is here to assist, but you’re still the captain of your JMeter ship!

Setting It Up: Configuration Made Simple

Getting started with Feather Wand is straightforward. It’s all configured through JMeter properties. Just grab the jmeter-ai-sample.properties file from the repo, copy its contents into your jmeter.properties or user.properties file, and tweak as needed. Here’s a rundown of the key options:

Property	Description	Default Value
anthropic.api.key	Your Claude API key (required)	N/A—get yours from Anthropic
claude.default.model	The Claude model to use	claude-3-sonnet-20240229
claude.temperature	Controls AI creativity (0.0-1.0)	0.7
claude.max.tokens	Max response length	1024
claude.max.history.size	Chat history length	10
claude.system.prompt	Guides the AI’s tone and focus	See sample file
anthropic.log.level	Logging for API requests	Empty (disabled)

Make It Your Own with a Custom Prompt

Want the AI to focus on specific JMeter quirks or follow your own guidelines? Customize the claude.system.prompt in the properties file. The default prompt is JMeter-savvy and user-friendly, but you can tailor it to your heart’s content.

The Magic of @this

One standout feature is the @this command. Select any element in your test plan—like a sampler or thread group—and type something like:

“What does @this do?”
“How can I optimize @this?”
“Best practices for @this?”

Feather Wand will analyze the selected element and deliver advice tailored to it. It’s like having a JMeter expert peek over your shoulder.

How to Get Started: Grab an Anthropic API Key

To unlock Feather Wand’s AI powers, you’ll need an Anthropic API key. Here’s the quick how-to:

Head to the Anthropic API site.
Sign up or log in.
Generate a new API key.
Paste it into the anthropic.api.key property in your JMeter config.
Check out the API key docs for more details.

Once that’s set, you’re ready to wave your Feather Wand and let the AI magic begin!

Why Feather Wand Matters

Performance testing with JMeter can be complex, time-consuming, and sometimes downright frustrating—especially when you’re racing against deadlines or wrestling with intricate systems. Feather Wand lightens the load by blending AI’s problem-solving prowess with JMeter’s robust testing capabilities. Whether you’re brainstorming test designs, automating repetitive tasks, or scripting custom logic, this plugin is here to make the process smoother—and maybe even a little fun.

So, why not give it a try? Clone the repo, set it up, and let Feather Wand add a touch of magic to your next JMeter project. I’d love to hear your feedback—or your own “Bluey-inspired” ideas for making it even better!

Happy testing!

Conquer Your Grocery Budget with Clip It!: The Free Chrome Extension That Makes Kroger Savings a Breeze

NaveenKumar Namachivayam ⚡ — Mon, 19 Aug 2024 15:26:30 +0000

Let's face it: grocery shopping can feel like a battle against a constantly inflating budget. We meticulously scan weekly ads, clip coupons with the precision of a surgeon, and still, sometimes, that final receipt can feel like a punch to the gut. But what if I told you there's a secret weapon in the fight for grocery savings, a tool so simple and effective it could revolutionize the way you shop at Kroger?

Introducing Clip It!, a free Chrome extension designed to supercharge your digital coupon game and make saving money at Kroger easier than ever before.

Download now from Chrome Web Store.

https://youtu.be/Y3mBXwzF99k

Ditch the Scissors, Embrace the Future of Couponing

Remember the days of meticulously cutting coupons from newspapers and magazines, only to forget them at home or realize they expired last week? With Clip It!, those days are gone for good. This innovative extension eliminates the hassle of paper coupons and brings the power of digital savings directly to your fingertips.

How Clip It! Makes Kroger Shopping a Breeze

Imagine this: you're browsing the digital coupon section on Kroger.com, faced with a seemingly endless list of offers. Clicking each coupon individually feels like a tedious chore, but with Clip It!, a single click is all it takes. That's right, this powerful extension will automatically clip every available digital coupon to your account in an instant.

But Wait, There's More! Clip It! is Packed with Features

Customize Your Clipping Experience: Not interested in every single offer? No problem! Clip It! lets you set a maximum number of coupons to clip using a simple slider, ensuring you only get the deals relevant to your shopping list.
On the Hunt for Freebies? The "Clip Only Free Coupons" feature (currently in its experimental phase) is your new best friend. Activate this setting and watch as Clip It! scours the digital aisles for those coveted freebie offers.
Starting Fresh Each Week? Easily unclip all existing coupons with one click, creating a clean slate for the new week's deals and keeping your digital coupon stash organized.

Why Clip It! is a Must-Have for Kroger Shoppers

Say Goodbye to Missed Savings: Never again will you experience the frustration of forgetting to clip a coupon or discovering a deal after you've already checked out. Clip It! ensures you're maximizing every possible saving opportunity.
Reclaim Your Precious Time: Time spent clipping coupons is time you could be using for more enjoyable activities. Clip It! streamlines the couponing process, giving you back valuable time in your busy schedule.
Shop Smarter, Not Harder: Clip It! empowers you to make informed decisions about your grocery purchases, helping you stick to your budget without sacrificing quality or variety.

Ready to Take Control of Your Grocery Budget?

Join the growing number of savvy Kroger shoppers who are ditching the scissors and embracing the ease and convenience of Clip It!. This free and user-friendly extension is the ultimate tool for maximizing your savings and making every shopping trip a victory for your wallet.

Don't wait another minute! Download Clip It! today and experience the future of couponing!

P.S. Want to learn more about Clip It! and get answers to any questions you might have? Visit the extension's comprehensive help page for detailed information and helpful FAQs.

Unlocking the Power of Large Language Models with Kel: Enhancing Workflow and Productivity

NaveenKumar Namachivayam ⚡ — Wed, 20 Dec 2023 13:38:50 +0000

If you're not using Large Language Models (LLMs) in your daily work, you're missing out. You can learn, improve, and optimize your developer and testing activities using any LLMs (free or paid). Even this blog article has been grammar checked by the OpenAI GPT-4 model. It is written by me, but improved by an AI. There are thousands of apps available in the marketplace which are built on top of LLM APIs. However, their monthly prices are typically higher than average. It harnesses powerful LLMs at its core. LLM companies charge in cents, but you need to pay in dollars to use those apps. That's why I created my own app to bring your own key to power up the workflow in Command Line Interface.

What is Kel?

Kel means ask in Tamil. Kel is a simple utility which helps you to connect between your question and the LLM. It takes your questions to the LLM and prints its responses in your terminal.

Kel is built using Python and the respective LLM's library. It is free and open source.

Features of Kel

CLI based utility
Bring your own API key
Supports OpenAI, Anthropic, Ollama, and Google models.
Supports OpenAI assistant model
Supports styling configuration
Displays stats such as response time, tokens, and more.
Displays ~pricing information
and more

How to install Kel?

There are a couple of ways you can install Kel.

pip

By using pip it is easy to install Kel.

pip install kel-cli

pipx

python3 -m pip install --user pipx
python3 -m pipx ensurepath
pipx install kel-cli

Once it is installed, run the below commands to configure the config.toml file.

# copy the default config file to current user's home directory
curl -O https://raw.githubusercontent.com/QAInsights/kel/main/config.toml
mkdir -p ~/.kel
mv config.toml ~/.kel/config.toml

Demo

Here is a quick demo of kel.

Kel Commands

Before you ask your questions using kel, you need a valid API key either from OpenAI, Anthropic, or Google. If you want free option, you can spin up https://ollama.ai/ in your local and configure the endpoint in config.toml

Once the API key setup is done, issue the below commands.

kel -v

To view the help, issue

kel -h

Now, let us ask some questions to the OpenAI model.

kel "git command to blame"

By default, kel answers the questions which are relevant to software engineering e.g.

kel "What is the mass of the moon?"

But you can change this behavior by adding your own prompt e.g.

kel "What is the mass of the moon?" -p "You are a physicist"

This is the magic of kel. It is flexible and customizable. It has umpteen options to customize based on your needs.

You can also change the LLM and its model on the fly. Let us ask the same question to Anthropic's Claude model.

More Kel

Kel also supports the OpenAI Assistant model where you can upload a file and ask questions about that. It is an awesome feature for performance engineers who need to analyze the raw results by using AI magic.

I am saving this feature for my next blog article. So what is next?

Based on the user's feedback, I will integrate more prominent models into Kel so that you can improve your workflow. Please let me know in the comments or in GitHub issues.

Conclusion

Using Large Language Models (LLMs) in your daily work can greatly improve and streamline your developer and testing tasks. Kel is a free and open-source utility that allows you to connect with LLMs using your own API key. It offers a command-line interface, supports various LLM models, and provides customization options. Kel's flexibility and convenience make it a valuable tool for improving workflow and productivity.

Introducing the Apache JMeter Docker Extension

NaveenKumar Namachivayam ⚡ — Mon, 06 Nov 2023 14:18:00 +0000

Docker Extensions was announced as a beta at DockerCon 2022. Docker Extensions became generally available in January 2023. Developing performance tools' related extensions was on my to-do list for a long time. Due to my master's degree I couldn't spend time learning Docker Extensions SDK. I expected someone would have created the extension by now, considering it's almost 2024. It's surprising to me that none has been developed as far as I know. But no more. Introducing the Apache JMeter Docker Extension. Now you can run Apache JMeter tests in Docker Desktop without installing JMeter locally. In this blog post, we will explore how to get started with this extension and understand its functionality. We will also cover generating HTML reports and other related topics.

About Docker Extensions

Docker Extensions enables third parties to extend the functionalities of Docker by integrating their tools. Think of it like a mobile app store, but for Docker.

I frequently use the official Docker Disk Usage extension to analyze disk usage and free up unused space.

Extensions enhance the productivity and workflow of developers. Check out the Docker Extension marketplace for some truly amazing extensions. Go see it for yourself!

Prerequisite for Docker Extension

The only prerequisite for Docker Extension is to have Docker Desktop 4.8.0 and later installed in your local.

Apache JMeter Docker Extension

Apache JMeter Docker Extension is an open source, lightweight extension and the only extension is available as of this writing. It will help you to run JMeter tests on Docker without installing JMeter locally.

This extension simplifies the process of setting up and executing JMeter tests within Docker containers, streamlining your performance testing workflow. Whether you're a seasoned JMeter pro or just getting started, this tool can help you save time and resources.

Features

Includes base image qainsights/jmeter:latest by default.
Light-weight and secured container
Supports JMeter plugins
Mount volume for easy management
Supports property files
Supports proxy configuration
Generates logs and results
Intuitive HTML report
Displays runtime console logs
Timely notifications

How to install Apache JMeter Docker extension?

Installation is a breeze. There are two ways you can install the extension.

Command Line

Run docker extension install qainsights/jmeter-docker-extension:0.0.1 in your terminal and follow the prompts.

$> docker extension install qainsights/jmeter-docker-extension:0.0.1     
                                                            
Extensions can install binaries, invoke commands, access files on your machine and connect to remote URLs. 
Are you sure you want to continue? [y/N] y

Image not available locally, pulling qainsights/jmeter-docker-extension:0.0.1...
Extracting metadata and files for the extension "qainsights/jmeter-docker-extension:0.0.1"
Installing service in Desktop VM...
Setting additional compose attributes
Installing Desktop extension UI for tab "JMeter"...
Extension UI tab "JMeter" added.
Starting service in Desktop VM......
Service in Desktop VM started
Extension "JMeter" installed successfully

Web

Here is the direct link to install the JMeter extension. Follow the prompts to get it installed.

Install JMeter Docker Extension

Click on Install anyway to install the extension.

How to get started with JMeter Docker Extension?

After installing the JMeter Docker extension, navigate to the left sidebar as shown below, then click on JMeter.

Now it is time to execute our first tests on Docker using JMeter extension.

The following are the prerequisites to execute the JMeter tests.

valid JMeter test plan
optional proxy credentials
optional JMeter properties file

The user interface is pretty simple, intuitive, and self-explanatory. All it has is text fields, buttons, and the output console log.

The extension has the following sections:

Image and Volume
- This extension works well with the qainsights/jmeter:latest image
- Other images might not work; I have not tested it.
- Mapping the volume from the host to the Docker container is crucial to share the test plan, CSV test data, other dependencies, property files, results, and other files.
Test Plan
- A valid test plan must be kept inside the shared volume.
Property Files
- This section helps you to pass the runtime parameters to the JMeter test plan.
Logs and Results
- This section helps you to configure the logs and results. After each successful test, logs and an HTML report will be generated and saved in a shared volume.
Proxy and its credentials
- Optionally you can send a proxy and its credentials. This is helpful when you are on the corporate network so that the container can access the application being tested.

Below is the example test where the local volume /Users/naveenkumar/Tools/apache-jmeter-5.6.2/bin/jmeter-tests is mapped to the container volume jmeter-tests.

Here is the content in /Users/naveenkumar/Tools/apache-jmeter-5.6.2/bin/jmeter-tests folder in my local.

Above artifacts will be shared with the Docker container once it is up and running.

In the above example, /jmeter-tests/CSVSample.jmx will be executed inside the container. It will use the below loadtest.properties.

Once all the values are configured, hit the Run JMeter Test button.

During the test you can pay attention to a couple of sections. One is console logs. For each test, the runtime logs will be streamed from the Docker container as shown below.

In case there are any errors, you can check them under Notifications section.

Once the test is done, Notifications will display the status and the location of HTML report (your mapped volume).

Here is the auto-generated HTML report.

How JMeter Docker Extension works and its architecture?

On a high level, how this extension is simple as shown in the below diagram. Once you click on the Run button, the extension first validates all the input and the required fields.

If the validation check passes, then the extension will look up the artifacts from the mapped volume. Then it passes all respective JMeter arguments to the image qainsights/jmeter:latest.

If the image is not present, it will get pulled from the Docker container registry.

Then the container will be created up by Docker and perform the test execution.

During the test execution, container logs will be streamed to the output console logs.

To stop the test, click the Terminate button to nuke the container. This action is irreversible and will not generate any test results.

Once the test is done, HTML report and the logs will be shared with the mapped volume.

How to uninstall the extension?

There are two ways to uninstall the extension. Using the CLI, issue docker extension uninstall qainsights/jmeter-docker-extension:0.0.1 or from the Docker Desktop.

Navigate to Docker Desktop > Extensions > JMeter, then click on the menu to uninstall as shown below.

Known Issues

There are a couple of issues (or more :) if you find) you can start the test as much as you want to generate more load to the target under test.

Supports only frequently used JMeter arguments. If you would like to add more arguments, please raise an issue in the GitHub repo.

Upcoming Features

There are a couple of features I am planning to implement based on the reception.

Add a dashboard to track the tests
Display graphs/charts runtime
Way to add JMeter plugins on the fly

If you have any other exciting ideas, please let me know.

JMeter Docker Extension GitHub Repo

Conclusion

In conclusion, the introduction of the Apache JMeter Docker Extension is a significant step forward for developers and testers looking to streamline their performance testing workflow. With this open-source and lightweight extension, you can run JMeter tests in Docker without the need to install JMeter locally, saving you time and resources.

Despite a few known issues and limitations, such as supporting only frequently used JMeter arguments, the extension holds promise for the future.

In summary, the Apache JMeter Docker Extension provides a valuable tool for developers and testers, enabling them to perform JMeter tests efficiently within Docker containers, and it's a welcome addition to the Docker Extension ecosystem. It's worth exploring for anyone involved in performance testing and looking to simplify their workflow.

Deep-dive into Vegeta - HTTP load testing tool and library

NaveenKumar Namachivayam ⚡ — Tue, 31 Oct 2023 00:32:15 +0000

As a performance engineer, you know how crucial it is to expand your skillset and become proficient with various tools. In your demanding role, ensuring the optimal performance of applications and systems is paramount. To achieve this, you need a diverse range of tools and techniques in your arsenal.

In this blog article, you're about to embark on a journey to explore a valuable addition to your toolkit: Vegeta, an HTTP load testing tool and library. As a performance engineer, you're likely no stranger to the importance of load testing in evaluating and enhancing system performance. Vegeta is one such tool that will help you accomplish this more effectively.

By delving into the world of Vegeta, you'll gain insights into its features, capabilities, and practical applications for load testing. This knowledge will empower you to handle a higher volume of users and requests while ensuring your systems maintain peak performance. So, let's dive in and discover how Vegeta can further elevate your performance engineering expertise.

Vegeta - HTTP load testing tool and library

Vegeta is an open-source HTTP load testing tool and library designed to help evaluate and analyze the performance of web services, servers, and applications by simulating a large number of HTTP requests. It was created in the Go programming language and is widely used for performance testing and benchmarking.

Vegeta is particularly popular among developers and performance engineers because of its simplicity, ease of use, and the ability to conduct performance tests efficiently. It's worth noting that while Vegeta is a powerful tool for HTTP load testing, users should always ensure they have appropriate permissions and are following ethical and legal guidelines when testing web services and applications.

Vegeta Features

CLI and Go-based tool
Easy to learn and pluggable in automation workflow
Customizable HTML reporting
Simple distributed load testing using pdsh
Easy to install, update, and manage
Avoids Coordinated Omission

Install Vegeta

In macOS, you can install Vegeta using brew.

brew update && brew install vegeta

For Windows, make sure you have installed Go. To install vegeta, use

go get -u github.com/tsenart/vegeta

To validate vegeta:

vegeta -version

Simple Load Test

To begin a simple load test in vegeta, issue the below command.

echo "GET http://localhost:8080" | vegeta attack -duration=10s | tee results.bin | vegeta report

The above command will attack the localhost for 10s, store the results in results.bin and creates a report in the current directory.

The results will be stored in a bin format. To create a HTML report, use the below command:

cat results.bin | vegeta plot > plot.html

To plot histogram in the terminal, issue the below command:

cat results.bin | vegeta report -type="hist[0,100ms,200ms,300ms]"

Vegeta defaults

By default vegeta uses the following properties:

CPUs - number of CPUs you have
Number of connections - 10000
Rate - 50 requests per second
DNS TTL - 0s
Duration of the test - infinity
HTTP2 - if the server supports
Maximum size of response body - no limit
Maximum number of workers - 18446744073709551615
Output file - stdout
Redirects - 10
Targets - stdin
Timeout - 30s
Workers - 10

There are defaults for plot and report as well.

Important arguments to remember

When running a performance test, it is paramount to configure the right values so that the test will work as per workload model. The following are the important command and arguments to remember in vegeta.

attack - this command generates load and executes the HTTP instructions. It is important to configure the duration of the test in seconds and rate - number of requests per time unit i.e. throughput.

If the HTTP verb is POST, then you need to add appropriate body, headers, tls, redirects, resolvers and more.

When it comes to report, ensure you mention histogram buckets, output file, and type.

For the plot, configure the threshold, output, and title.

More examples

If you are new to vegeta, below are the handy examples which will be useful.

Attacking with headers

echo "GET http://localhost:8080
X-Track: vegeta-test" | \
vegeta attack -duration=10s | \
tee results.bin | \
vegeta report

Attacking with multiple endpoints

echo "GET http://localhost:8080
X-Track: vegeta-test"

GET http://localhost:8080/leaderboard" | \
vegeta attack -duration=10s -name emojivoto | \
tee results.bin | \
vegeta report

Attacking with POST request

echo "POST http://localhost:8080" | vegeta attack -duration=10s | tee results.bin | vegeta report

Attacking with rate

echo "GET http://localhost:8080" | vegeta attack -duration=10s -rate=100/s | tee results.bin | vegeta report

Attacking with payload

echo "POST http://localhost:8080
@data.json" | vegeta attack -duration=10s | \
tee results.bin | \
vegeta report

Attacking with comments

echo "POST http://localhost:8080
# sending with payload
@data.json" | vegeta attack -duration=10s | \
tee results.bin | \
vegeta report

Distributed load testing in Vegeta

Distributed testing is the core feature for any performance testing tool. It helps in distributing the load to scale the workload. Vegeta's approach is kind of unique while comparing with other tools like JMeter, k6, or Locust.

Vegeta leverages pdsh (Parallel Distributed Shell) is an open-source, high-performance parallel remote shell utility that allows system administrators and users to execute shell commands or scripts on multiple remote hosts simultaneously. It is particularly useful for managing and automating tasks on multiple servers or clusters in parallel.

pdsh is widely used in environments where parallel or distributed system administration and automation are essential. It simplifies the management of large clusters of servers and allows administrators to streamline tasks that would otherwise be time-consuming when performed on each host individually.

To demo the distributed load testing feature in vegeta, let us spin up multiple virtual machines using multipass.

Multipass is a lightweight, cross-platform virtual machine (VM) management tool developed by Canonical, the company behind Ubuntu Linux. It provides a simple and convenient way to create, manage, and run virtual machines on various operating systems, including Windows, macOS, and Linux. Multipass is designed to be user-friendly, making it easy for developers, sysadmins, and others to work with virtual machines for development, testing, and various computing tasks.

Multipass is commonly used for various purposes, including software development, testing, running isolated development environments, and experimenting with different Linux distributions. It simplifies the process of working with virtual machines, especially for those who prefer a command-line interface and want a straightforward way to create and manage VMs.

You can check https://multipass.run/install to get started. First, let us create two virtual machines (vm) for this demo. The below command will create two vms worker1 and worker2 with 2 CPU and 4 GB memory each with Ubuntu 23.04.

multipass launch --name worker1 23.04 -c 2 -m 4gb

multipass launch --name worker2 23.04 -c 2 -m 4gb

Once it is created, you can list out all the vms using the below command.

multipass list

The next step is to login into the worker1 and issue the below commands.

sudo apt update
sudo apt install golang -y

To install vegeta, grab the right download url from https://github.com/tsenart/vegeta/releases/tag/v12.11.1 and download using the below command.

curl -L -o vegeta_12.11.1_linux_arm64.tar.gz https://github.com/tsenart/vegeta/releases/download/v12.11.1/vegeta_12.11.1_linux_arm64.tar.gz

tar -xf vegeta_12.11.1_linux_arm64.tar.gz

sudo mv vegeta /usr/local/bin/

Now repeat the above steps for worker2. Once the vegeta is installed, return to your local to install pdsh using the below command.

brew install pdsh

The next step is to grab the IP address of worker1 and worker2 using the below command.

multipass list

To SSH into the VMs, you need to copy your public key into them using ssh-copy.

ssh-copy-id -i ~/.ssh/id_rsa.pub ubuntu@192.168.205.13
ssh-copy-id -i ~/.ssh/id_rsa.pub ubuntu@192.168.205.14

Now set this environment variable in your local.

PDSH_RCMD_TYPE=ssh

Trigger the attack

pdsh -l ubuntu -b -w '192.168.205.13,192.168.205.14' 'echo "GET http://example.com" | vegeta attack -rate=2 -duration=5s > result.bin'

pdsh: This is the command used to run a command on multiple remote servers in parallel.
-l ubuntu: This option specifies the username to use when connecting to the remote servers. In this case, it's set to "ubuntu."
-b: This option tells pdsh to execute the specified command in the background, meaning it will not wait for the command to finish on each remote server before moving on to the next one.
-w '192.168.205.13,192.168.205.14': This option specifies the list of remote servers to target. In this case, it's set to two IP addresses: 192.168.205.13 and 192.168.205.14.
'echo "GET http://example.com" | vegeta attack -rate=2 -duration=5s > result.bin': This is the actual command that will be executed on each of the specified remote servers. Let's break it down further:
- echo "GET http://example.com": This part of the command sends an HTTP GET request to "http://example.com." It's used to generate HTTP traffic for the load test.
- |: This pipe symbol is used to send the output of the preceding command as input to the following command.
- vegeta attack -rate=2 -duration=5s > result.bin: This part of the command utilizes the vegeta load testing tool to perform a load test. Here's what each part does:
  - vegeta attack: This is the command to start a load test attack with vegeta.
  - -rate=2: It specifies the request rate of 2 requests per second.
  - -duration=5s: The load test will run for 5 seconds.
  - > result.bin: The output of the load test will be saved to a file called "result.bin." The > symbol is used to redirect the output to the specified file.

Once the attack is done, it is important to collect the results from each machine using the below command.

for machine in 192.168.205.13 192.168.205.14; do
    scp ubuntu@$machine:~/result.bin $machine.bin &
done

After the results have been collected, below command helps you to plot the combined HTML report.

vegeta plot 192.168.205.13.bin 192.168.205.14.bin > combined_report.html

# for CLI output
vegeta report *.bin

Integrations

For real time results plotting, vegeta gels with jplot and jaggr
Integrates with Prometheus and Grafana

Conclusion

In conclusion, as a performance engineer, it's crucial for you to expand your toolkit with the right tools to succeed in your demanding role. You know that ensuring optimal performance for your applications and systems is an ongoing challenge, but with the right set of tools and techniques, you can tackle this challenge effectively.

Throughout this article, we've taken you on a journey to explore a valuable addition to your toolkit: Vegeta, an HTTP load testing tool and library. You understand that load testing is a fundamental part of evaluating and enhancing system performance, and Vegeta offers a robust solution to help you achieve your goals.

By delving into the world of Vegeta, we've provided you with insights into its features, capabilities, and practical applications for load testing. Equipped with this knowledge, you'll be better prepared to handle a higher volume of users and requests, all while ensuring your systems maintain peak performance.

We've covered the basics of installing Vegeta on different platforms and shown you how to perform simple load tests. We've also delved into more advanced topics like distributed load testing using pdsh. You're now aware of the importance of correctly configuring the attack, report, and plot settings to meet your specific testing needs.

Furthermore, we've demonstrated how Vegeta integrates with other tools like jplot and jaggr for real-time results plotting, as well as its seamless integration with Prometheus and Grafana for more comprehensive performance monitoring.

In your role as a performance engineer, you know that having the right tools can make all the difference. By adding Vegeta to your arsenal, you'll be better equipped to tackle the challenges of performance testing and ensure that the systems you manage continue to perform at their best. So why wait? Dive into the world of Vegeta and elevate your performance engineering expertise today. Your applications and systems will thank you for it.

Browser Performance Testing using k6

NaveenKumar Namachivayam ⚡ — Fri, 20 Oct 2023 13:26:12 +0000

In this blog post you will learn how to get started with browser performance testing using k6. Client-side performance is paramount to validate the performance of your application along with the network load i.e. protocol load e.g. APIs. Not many tools are sophisticated when it comes to measuring end-to-end performance. Opentext LoadRunner TruClient protocol is one of the tool at its best when it comes to measuring front-end performance.

JMeter w/ Selenium can be used to measure the browser performance. But the maintenance is nightmare and too flaky. If you do not want to use any tool, you can leverage the Chromium Developer Protocol.

What is Chromium Developer Protocol?

It is often referred to as the Chrome DevTools Protocol (CDP), is a set of APIs and tools that allow developers to interact with and inspect web pages in the Chromium-based web browsers like Google Chrome, Microsoft Edge, and others. It provides a way to access and control various aspects of web pages, such as inspecting the Document Object Model (DOM), manipulating CSS, monitoring network activity, debugging JavaScript, and much more.

Getting Started with k6 browser

k6 is getting traction among developers and performance engineers. After getting acquired to Grafana, there are numerous improvements in the k6 ecosystem. I have already published a complete series on k6, please check it out if you are new to k6.

https://www.youtube.com/playlist?list=PLJ9A48W0kpRJKmVeurt7ltKfrOdr8ZBdt

k6 Series

No more building xk6 browser from the binaries. The latest version of k6 is now bundled with the browser capability to test the front-end performance.

The following are the prerequisites to get started with k6 browser:

the latest version of k6
Chrome browser in your local

You can install k6 in Windows, Linux, and macOS. Here is the command to install k6 in Mac.

brew install k6

To verify the installation, use k6 version.

k6 browser is built on top of Playwright API. Playwright is an open-source automation library for browsers that allows developers and testers to automate tasks and interactions with web pages in Chromium, Firefox, and WebKit-based browsers.

It provides a JavaScript API that makes it easy to write browser automation scripts and run them across different browser engines. Playwright is developed by Microsoft and is designed to be a more powerful and user-friendly alternative to other browser automation libraries like Puppeteer.

Hello, Browser in k6 browser

Copy and paste the below code and save it as hello-browser.js.

import { browser } from 'k6/experimental/browser';

export const options = {
  scenarios: {
    ui: {
      executor: 'shared-iterations',
      options: {
        browser: {
          type: 'chromium',
        },
      },
    },
  },
  thresholds: {
    checks: ["rate==1.0"]
  }
}

export default async function () {
  const page = browser.newPage();

  try {
    await page.goto('https://example.com');    
  } finally {
    page.close();
  }
}

To run the script, k6 run hello-browser.js

Here is the output.

Let us break down the code one by one.

Import the browser object from the k6/experimental/browser module. This object is used to interact with web pages in your performance test.
Define the options object, which specifies the configuration for the k6 test.
- scenarios: This section defines different test scenarios. In this case, there is only one scenario named "ui."
  - executor: It specifies the execution mode for the scenario, which is set to "shared-iterations." In this mode, virtual users share a fixed number of iterations.
  - options: Further options for the scenario, including the type of browser to be used. Here, it's set to "chromium," indicating the Chromium browser.
- thresholds: This section defines the criteria for passing or failing the test.
  - checks: It specifies a threshold for a check named "rate," which is set to 1.0. This means that all checks in the test should have a success rate of 100% for the test to pass.
Export a default asynchronous function. This function will be executed by k6 during the performance test.
- Inside the function, a new page is created using browser.newPage(). This represents a virtual user's interaction with a web page.
- Within a try block, the virtual user navigates to the URL 'https://example.com' using page.goto(). This simulates a user visiting the specified web page.
- In the finally block, the page is closed using page.close(). This ensures that resources are properly cleaned up after the virtual user has finished interacting with the web page.

Here is the output breakdown.

browser_data_received: This section shows statistics related to data received by the browser during the test.
- 1.6 kB: The total amount of data received by the browser during the test.
- 1.6 kB/s: The data receiving rate, indicating the rate of data transfer per second.
browser_data_sent: This section shows statistics related to data sent by the browser during the test.
- 343 B: The total amount of data sent by the browser during the test.
- 331 B/s: The data sending rate, indicating the rate of data transfer per second.
browser_http_req_duration: These statistics provide information about the duration of HTTP requests made by the browser.
- avg=422.89ms: The average duration of HTTP requests in milliseconds.
- min=422.89ms: The shortest (minimum) request duration.
- med=422.89ms: The median (middle) request duration.
- max=422.89ms: The longest (maximum) request duration.
- p(90)=422.89ms: The 90th percentile of request durations.
- p(95)=422.89ms: The 95th percentile of request durations.
browser_http_req_failed: This section provides information about failed HTTP requests made by the browser.
- 0.00%: The percentage of HTTP requests that failed.
- ? 0: The number of successful requests (0).
- ? 1: The number of failed requests (1).
browser_web_vital_cls, browser_web_vital_fcp, browser_web_vital_lcp, browser_web_vital_ttfb: These sections report various web vital metrics that are important for measuring web page performance.
- These sections include metrics such as average, minimum, median, maximum, and percentiles for Core Web Vitals like Cumulative Layout Shift (CLS), First Contentful Paint (FCP), Largest Contentful Paint (LCP), and Time to First Byte (TTFB).
checks: This section reports on the success or failure of checks performed during the test.
- 0.00%: The percentage of checks that failed.
- ? 0: The number of successful checks (0).
- ? 0: The number of failed checks (0).
data_received, data_sent: These sections show statistics related to data received and sent during the test. In this case, no data was sent or received.
iteration_duration: These statistics provide information about the duration of iterations (test cycles).
- avg=678.25ms: The average duration of iterations in milliseconds.
- min=678.25ms: The shortest (minimum) iteration duration.
- med=678.25ms: The median (middle) iteration duration.
- max=678.25ms: The longest (maximum) iteration duration.
- p(90)=678.25ms: The 90th percentile of iteration durations.
- p(95)=678.25ms: The 95th percentile of iteration durations.
iterations: This section provides information about the number of iterations (test cycles) completed during the test.
- 1: The total number of iterations.
- 0.96512/s: The rate at which iterations were executed per second.
vus: This section shows statistics related to the virtual users (VUs) used in the test.

1: The current number of virtual users.
min=1: The minimum number of virtual users.
max=1: The maximum number of virtual users.

vus_max: This section provides information about the maximum number of virtual users.

1: The maximum number of virtual users during the test.
min=1: The minimum number of virtual users during the test.
max=1: The maximum number of virtual users during the test.

Headless Mode

By default, k6 runs the test in headless mode. To turn off it, issue K6_BROWSER_HEADLESS=false k6 run <your-script>.js

This will launch the Chromium browser and perform the scripted actions.

You can also interact with the application using Locator object. k6 also supports Asynchronous operations.

Recommended Way to Test

It is always ideal to test both the APIs and the front-end simultaneously to get the real simulation of production. You can create both the tests in one script, or you can write two different scripts and run it simultaneously.

Conclusion

In conclusion, browser performance testing with k6 is a valuable addition to your toolkit for assessing and optimizing the performance of web applications. With its user-friendly approach, bundled browser capability, and the power of the Chromium Developer Protocol, k6 simplifies the process of evaluating client-side performance and empowers you to build faster, more efficient, and more reliable web applications. It's a powerful tool that every performance engineer and developer should consider in their testing repertoire.

What's new in Apache JMeter 5.6?

NaveenKumar Namachivayam ⚡ — Wed, 02 Aug 2023 02:08:22 +0000

In this blog post, let us see what's new in Apache JMeter 5.6. You can check my last post about JMeter 5.5. JMeter 5.6 was long due from the Apache community, it has been more than a year since we got an update.

Apache JMeter 5.6

There are no new and noteworthy changes in JMeter 5.6. But it comes with improvements and bug fixes. The following are the improvements made in JMeter 5.6.

Thread Groups

Issue #5682 Pull request #717 - Open Model Thread Group: avoid skipping rows from CSV Data Set Config
Support custom thread group implementations in "Add think time" and "Save as test fragment" actions
Open Model Thread Group: interrupt pending HTTP requests and other Interruptible test elements on test stop

HTTP Samplers and Test Script Recorder

Pull request #5911 - Use Caffeine for caching HTTP headers instead of commons-collections4 LRUMap
Pull request #5947 - Fetch resources referenced in <link "rel"="preload"...> elements
Pull request #5869 - Allow more templates to format sampler names in the recorder: #{url}, #{method}, #{scheme}, #{host}, #{port}

Other samplers

Pull request #5909 - Use Caffeine for caching compiled scripts in JSR223 samplers instead of commons-collections4 LRUMap

Apart from the above improvements, there are general enhancements available in 5.6 along with non-functional changes such as JARs upgrades, accessibility, and more.

I have a surprising feature in JMeter 5.6 for you, which is editable in almost all the checkbox controls. This was not possible prior to JMeter 5.6.

By default, the checkbox has two attributes: either checked or unchecked. But starting from JMeter 5.6, you can enable the expression so that you can programmatically control the attributes.

Here is how you can edit the checkbox properties.

Right-click on the checkbox where you want to add the expression as shown below.

Click "Use Expression" This will launch a drop-down as shown below.

Here you can select true to enable the checkbox, false to uncheck the checkbox, or you can use either the expressions ${__P(property_name)} or ${variable_name}

__P can be used to read the values from the JMeter CLI. ${} can be used to read within the JMeter test plan.

Checkbox expressions usecases

You may think where this feature will be useful. Actually it has various usecases:

Test different thread groups consecutively.
to test various HTTP sampler settings such as keep alive, multi-form data, headers, and more.
Test various thread group properties

Download Apache JMeter 5.6

Introducing PerfGPT - analyze your performance test results using OpenAI

NaveenKumar Namachivayam ⚡ — Fri, 10 Mar 2023 16:23:50 +0000

In the past couple of posts we have discussed how to use ChatGPT for JMeter tasks and use cases for performance engineers. In this blog post, I am happy to introduce PerfGPT an open source tool to analyze your performance test results using the OpenAI model.

What is PerfGPT?

PerfGPT is an open source web application which helps in analyzing performance test results using the OpenAI model. It is completely free to use, even for commercial purposes.

About PerfGPT

PerfGPT backbone is OpenAI API. PerfGPT is a lightweight web application which is built using Flask - a Python framework for web development.

How to use PerfGPT?

Head to https://perfgpt.ai/ to login using GitHub account.

PerfGPT Login

PerfGPT requires only minimal info from your GitHub account. It will not read nor make any changes to your repos. After successful login, click Upload button which will take you to the upload page.

You can upload your test results either in JSON, CSV, or JTL. The recommended upload format is CSV. Select the file and then click on the Upload button.

Upload to PerfGPT

Upon clicking the Upload button, PerfGPT will process the data and present its findings as shown below.

PerfGPT Results

PerfGPT generates two summaries: High level and Detailed summary. This analysis will help performance engineers to draw the conclusion from the raw performance test results without spending more time on manual analysis using spreadsheet programs or analytics tools.

Features

Free and Open Source
No need to use your OpenAI API key
PerfGPT will not read or store your raw test data.
Fast OpenAI analysis for your raw performance results
Tool agnostic analysis. You can upload the results from any performance testing tools.
Slack integration

Limitations

10 MiB file upload size limit
10 uploads per month
Results accuracy still needs improvement. Eventually the OpenAI model will be good at it.

Conclusion

PerfGPT is a web application that is both free and open source. It assists performance engineers in efficiently analyzing raw data through the use of an OpenAI model, allowing them to focus on their other responsibilities. Additionally, the OpenAI model will continue to enhance its precision in processing raw data in the near future.