The objective of the performance Testing to generate traffic against a MQ system and identify, how many messages /seconds, we can send to a RabbitMQ instance also the performance Benchmarking.

Testing Approach

• RabbitMQ is an open-source message-broker software (also known as message-oriented middleware) that originally implemented the Advanced Message Queuing Protocol and these are many baseline pointers are followed to achieve performance testing goals.
• One publisher publishes as fast as it can, while one consumer consumes as fast as it can Two publishers and no consumers (performance as the queue gets longer)
• One consumer consumes a long queue from the previous test (performance of consumers unaffected by publishers)
• One consumer consumes a long queue from the previous test (performance of consumers unaffected by publishers)
• Five queues, each has 1 publisher publishing at 10k messages/s and 1 consumer (the total expected throughput is 50k/s, we look at the latency)
• Fanout to 10 queues – 1 publishers and 10 consumers, a fanout exchange
• One publisher, one consumer, but only 1 unconfirmed message (the publisher waits for the confirmation of the previous message before sending the next one)
• Fan-in: 7000 publishers publishing 1 message per second, to a single queue
• 1000 publishers publish 10 messages/s, each to a different queue; each queue has a consumer as well (total expected throughput: 10k/s

Performance Matrices:

JMeter Matrices

• 90% Average Response Time
• Throughput
• Error Percentage
• Request per Second
• API Errors

Hardware Matrix

• CPU stats (user, system, iowait & idle percentages)
• Memory usage (used, buffered, cached & free percentages)
• Virtual Memory statistics (dirty page flushes, writeback volume)
• Disk I/O (operations & amount of data transferred per unit time, time to service
• operations)
• Free disk space on the mount used for the node data directory.
• File descriptors used by beam.smp vs. max system limit.
• TCP connections by state (ESTABLISHED, CLOSE_WAIT, TIME_WAIT)
• Network throughput (bytes received, bytes sent) & maximum network throughput.
• Network latency (between all RabbitMQ nodes in a cluster as well as to/from
• Clients)

Database Matrices

• High Response Query
• Block Query
• Missing Indexes
• InnoDB Buffer Pool Size

Important link for RabbitMQ:

https://github.com/jlavallee/JMeter-Rabbit-AMQP/blob/master/examples/RPC_Load_Test.jmx

https://github.com/aliesbelik/jmeter-amqp-plugin/releases/tag/v0.3.0

https://www.rabbitmq.com/install-windows.html

https://jatinanejablog.blogspot.com/2016/06/configure-jmeter-to-load-test-rabbit-mq.html

The post RabbitMQ Performance Testing first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

Performance monitoring and alerting are very crucial to measure the performance metrics of an application running in a production environment. In this blog post, we are going to talk about two popular open-source tools Prometheus and Grafana. This blog post is aimed at anyone who is trying to learn Prometheus and Grafana or has some experience with these tools.

What is Prometheus – It is an open-source tool for scrapping the performance metrics of any given hardware resource (CPU, VM, Cloud Virtual Machine, Router, etc.). Prometheus scraps the data with the timestamp which can be stored on a server and accessed using the PromQL. Prometheus has superb support API which makes Prometheus integration with any resource present in the Datacenter. Prometheus architecture is really scalable and 3rd party libraries and makes it more powerful.

What is Grafana – In Lehman’s term Grafana is a user interface for viewing the metrics scraped by Prometheus from various resources. Grafana is an open-source analytics and visualization tool. Grafana does not store any data, but instead, it relies on Prometheus to send the data so that dashboard can be prepared. Also, Grafana is used for sending notifications and mail alerts based on various thresholds. One of the cool features of the Grafana is Grafana Labs where you can go and download the dashboard prepared by other developers so that you do not have to re-invent the wheel.

1. Installation of Prometheus
Prometheus has a various ways of installation for example – pre-compiled binaries, from source, Docker. But to keep the installation simple we are going to use the pre-compiled binaries for installing Prometheus onto my Ubuntu Linux machine.

Go to Download Page of Prometheus and select the prometheus-x.xx.x.linux-amd64.tar.gz file for download. (Note- Here x.xx.x is version number)
Extract the download binary file. (Note- Replace x.xx.x with the downloaded version of Prometheus)

tar xf prometheus-x.xx.x.linux-amd64.tar.gz

3. Go into the extracted directory cd prometheus-x.xx.x.linux-amd64.tar.gz

4.Start the Prometheus server with the command. /Prometheus

5. The Prometheus server should start on port 9090
6. You can access the Prometheus graph UI by visit http://localhost:9090/graph

7. You can access the Prometheus metrics UI by Visit http://localhost:9090/metrics.
(I have used my Prometheus instance public IP)

2. How to create and Install Node exporter
Node exporter is responsible for fetching the statistics from various hardware and virtual resources in the format which Prometheus can understand and with the help of the Prometheus server those statistics can be exposed on port 9100.

There are many third-party Node exporters which can be used by SREs as well as DevOps based on their application needs. But primarily we look for the following metrics –

CPU usage
Memory usage
Disk usage
Network usage
2.1 How to Install Node exporter.
After installing the Prometheus in the previous step, the next package, we are going to install is **Node Exporter **. Node exported is used for collecting various hardware and kernel-level metrics of your machine.

Here are the download and installation steps –

Download the binary of Node exporter based on the operating system. (In my case I am using Ubuntu Linux machine)

3. Extract the download node exporter binary file. (Note- Replace x.xx.x with the downloaded version of node exporter)

tar xf node_exporter-*.*-amd64.tar.gz

4.Go into the extracted directory sudo mv node_exporter-*.*-amd64.tar.gz nodeexporter

The post Prometheus, Node Exporter and Grafana Setup in AWS EC2 Environment first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

Database Design: A well-designed database schema with appropriate indexing, relationships, and normalization can significantly improve query performance. Ensure that the database structure is optimized for the application’s data access patterns.
Indexing: Use indexes judiciously to speed up data retrieval operations. Indexes on columns frequently used in WHERE clauses can reduce query execution times.
Query Optimization: Write efficient SQL queries that minimize the amount of data processed and fetched from the database. Avoid complex subqueries and use database query optimization tools where available.
Caching: Implement caching mechanisms to store frequently accessed data in memory. Caching can reduce the load on the database and improve response times for read-heavy workloads.
Connection Pooling: Use connection pooling to manage database connections efficiently. Creating and closing connections for each user request can be resource-intensive and slow.
Resource Monitoring: Continuously monitor database performance metrics, such as CPU utilization, memory usage, and I/O activity. Detect and address resource bottlenecks promptly.
Normalization and Denormalization:Strike a balance between normalization (for data integrity) and denormalization (for query performance). Denormalization can reduce the need for complex joins but may require additional storage.
Partitioning: Partition large tables into smaller, more manageable chunks. This can improve query performance and maintenance tasks like backups.
Optimized Data Types: Use appropriate data types for columns to minimize storage requirements and improve query performance. Avoid using unnecessarily large data types.
Database Maintenance: Regularly perform database maintenance tasks such as index rebuilding, table optimization, and data archiving to ensure optimal performance over time.
Query Execution Plans: Analyze query execution plans to identify slow queries and potential indexing or optimization opportunities.
Concurrency Control: Implement appropriate concurrency control mechanisms to handle simultaneous database transactions efficiently.
Load Balancing: Use database load balancing to distribute queries across multiple database instances or replicas. This can improve both read and write performance.
Scaling Strategies: Plan for database scaling as the application grows. Options include vertical scaling (adding more resources to a single server) and horizontal scaling (distributing the database across multiple servers).
Backup and Recovery: Implement reliable backup and recovery strategies to minimize downtime in case of data loss or system failures.
Security and Permissions: Ensure that database security is robust and that user permissions are appropriately configured. Security-related queries should not introduce unnecessary overhead.
Logging and Monitoring: Implement comprehensive logging and monitoring to detect and diagnose performance issues in real-time. Log slow queries and errors for analysis.
Testing and Benchmarking: Conduct performance testing and benchmarking to simulate real-world scenarios and identify performance bottlenecks before they impact users.
Documentation: Maintain documentation that includes database schema diagrams, indexing strategies, and performance optimization plans for reference and knowledge sharing.

By addressing these key points and continuously monitoring and optimizing your database, you can ensure that it operates efficiently, delivers fast response times, and supports the performance requirements of your application.

The post Unlocking Seamless Speed: Elevating Database Performance Testing in the Software Industry first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

Resource Constraints: Insufficient hardware resources, such as CPU, memory, or network bandwidth, can lead to functionality breakdowns. When the application is under a heavy load, resource utilization may exceed capacity, causing performance degradation or failures.
Concurrency Issues: In multi-user environments, race conditions and concurrency issues can emerge when multiple users or threads access shared resources simultaneously. These issues may not be apparent during functional testing but can surface under load.
Database Overload: Database queries and transactions are often a common source of performance bottlenecks. If the database becomes overloaded with concurrent requests, it can lead to slow response times, timeouts, or data corruption.
Thread or Connection Pooling Limits: Many applications use thread or connection pooling to manage concurrent user connections. If the pool size is insufficient to handle the load, it can lead to functionality breakdowns as users are unable to establish connections or execute transactions.
Third-Party Services: Applications often rely on external services or APIs. Performance problems with third-party services, including high response times or service outages, can impact the application’s functionality under load.
Inefficient Code: Inefficient code or algorithms can lead to performance bottlenecks. During load testing, these inefficiencies may become more pronounced and can result in functionality breakdowns.
Inadequate Load Balancing: In a distributed system, if load balancing is not properly configured, certain nodes or components may become overloaded while others remain underutilized. This can lead to uneven performance and functionality issues.
Memory Leaks:Memory leaks, where the application does not release memory properly, can accumulate over time and cause the application to crash or become unresponsive during load testing.
Software Bugs:Load testing can uncover latent software bugs that only manifest under heavy load. These bugs may include race conditions, deadlocks, or other issues that affect functionality.
Incorrect Assumptions:The load testing environment may not accurately reflect the production environment, leading to incorrect assumptions about system behavior. Differences in configurations, data volumes, or network conditions can impact functionality.
To address and prevent functionality breakdowns during load testing:

<br>Identify Bottlenecks: Use performance monitoring and profiling tools to identify performance bottlenecks, resource constraints, and areas of code that require optimization.</br>

Tune Configuration: Adjust configurations, such as database connection pool sizes, thread counts, and resource allocations, to better accommodate the expected load.

Optimize Code: Review and optimize application code and database queries to improve efficiency and reduce resource consumption.

Test Realistic Scenarios: Design load test scenarios that closely mimic real-world user behavior and usage patterns to ensure that the testing accurately represents production conditions.

Perform Scalability Testing: Assess the application’s ability to scale horizontally or vertically to handle increased loads.

Prioritize Critical Functions: Prioritize testing of critical or high-impact functions that must remain functional under heavy load.

Continuous Testing: Implement continuous performance testing to catch regressions early in the development process.

Functionality breakdowns during load testing are an essential part of identifying and mitigating performance issues. By addressing these issues proactively, organizations can ensure that their applications perform optimally under real-world conditions.
Let’s connection both Manual and Performance exercise parallel with CalibreQA experts.We know how we can make a reliable system for customer enteric approach.
Email Us for POC : poc@calibreqa.com

The post Unmasking the Hidden Culprits: Why Functionality Breakdowns Occur During Load Testing first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

Let’s Understand why we have to use LoadRunner TrueClient Protocol

LoadRunner with TrueClient Protocol is a performance testing tool used for load testing and performance testing of web applications. Unlike traditional LoadRunner protocols that simulate network-level traffic, TrueClient Protocol operates at the user interface level, providing a more realistic testing environment. Here are some key points about LoadRunner with TrueClient Protocol:

User-Centric Testing: TrueClient Protocol allows you to script and replay user interactions with the web application, simulating real user behavior. This is particularly valuable for testing the performance and responsiveness of web applications from an end-user perspective.

Rich User Experience: TrueClient supports modern web technologies, including JavaScript-heavy applications, AJAX, and dynamic content, offering a comprehensive view of how users interact with your application.

Scripting Flexibility: With TrueClient, you can create scripts using a visual script recorder or a code editor. This flexibility allows testers and developers to choose the scripting approach that best suits their needs.

Script Reusability: TrueClient enables the reuse of scripts across different scenarios and load testing scenarios, saving time and effort in script development.

Rich Reporting: LoadRunner provides detailed performance reports and analysis, allowing you to identify performance bottlenecks and make informed decisions for optimization.

Cross-Browser Testing: TrueClient supports testing across various web browsers, ensuring compatibility and performance across different browser platforms.

Transaction Monitoring: You can define and monitor user transactions within TrueClient scripts, allowing you to measure response times for specific user actions.

Parameterization: Like other LoadRunner protocols, TrueClient supports parameterization, enabling the use of dynamic data and scenarios in your tests.

Load Testing Scalability: LoadRunner allows you to scale up the number of virtual users to simulate heavy loads and assess how your application performs under stress.

Integrated Performance Center: LoadRunner integrates with Performance Center, a centralized platform for managing and executing performance tests across multiple locations and environments.

In summary, LoadRunner with True Client Protocol is a powerful tool for performance testing web applications with a focus on replicating real user interactions. It provides a comprehensive set of features for scripting, testing, and reporting to help organizations ensure the reliability and performance of their web applications in a user-centric manner.

#TrueClient Protocol # Real User Experience #Precise Performance Testing #Performance Testing #Page Rendering time #Page Load Time #Page first to last byte behavior and response time

The post Performance Testing Realistic User Experience with LoadRunner TrueClient first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

1.Customer Data Protection: Banks handle a vast amount of personal and financial data belonging to their customers. Security testing ensures that this data is protected from unauthorized access, breaches, and theft.

2.Financial Transactions: Banking involves a variety of financial transactions, including transfers, payments, and investments. Security vulnerabilities could lead to unauthorized transactions, financial loss, and fraudulent activities.

3.Regulatory Compliance: The banking industry is heavily regulated to ensure data privacy and security. Compliance with regulations such as GDPR, PCI DSS, and others requires thorough security testing to avoid legal and financial consequences.

4.Reputation: A security breach in the banking sector can significantly damage the bank’s reputation and erode customer trust. Security testing helps prevent such breaches and showcases a commitment to customer safety.

5.Phishing and Social Engineering: Cybercriminals often target banking customers through phishing and social engineering attacks. Security testing identifies potential vulnerabilities in these attack vectors, ensuring customers are not duped.

6.Insider Threats: Security testing helps detect vulnerabilities that could be exploited by insiders with malicious intent, such as disgruntled employees or contractors.

7.Availability: Banking services need to be available round the clock. Security testing ensures that the systems are resilient and can withstand denial-of-service (DoS) attacks that could disrupt services.

8.Fraud Prevention: Security testing identifies weaknesses that could be exploited for fraudulent activities, including account takeovers and identity theft.

9.Mobile Banking: With the rise of mobile banking apps, security testing becomes even more critical to ensure that these apps are secure and protect sensitive data on various devices.

10.Third-Party Integrations: Banks often rely on third-party services, which can introduce security risks. Thorough security testing of these integrations is necessary to ensure the entire ecosystem remains secure.

11.Digital Transformation: As banks undergo digital transformation, they introduce new technologies and channels. Security testing is vital to ensure that these innovations don’t compromise the overall security posture.

security testing is crucial in the banking domain to safeguard customer data, protect financial transactions, comply with regulations, maintain reputation, prevent fraud, address insider threats, ensure availability, secure mobile banking, verify third-party integrations, and support ongoing digital transformation efforts. It’s a proactive measure to secure the foundation of trust upon which the banking industry operates Let’s connect and write email for Free security checkup.
Email Us: Security@calibreQA.com

#Security Testing #Data Protection #Financial Transactions #Regulatory Compliance #Insider Threats #Fraud Prevention

The post Fortifying Trust: Ensuring Unbreakable Security in the Banking World first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

Safeguarding Your Sensitive Network Data with Unyielding Protection.

In today’s digital landscape, safeguarding sensitive network data is of paramount importance. Cybersecurity stands as the fortress protecting your valuable assets from the constant threat of cyber-attacks. Our cutting-edge solutions are meticulously designed to shield your network from intruders and keep your data safe and secure.

Why Choose Our Cyber Security Services?

Robust Defence: Our cybersecurity solutions deploy state-of-the-art technologies, firewalls, and encryption protocols to fortify your network’s defences, ensuring a formidable barrier against potential threats.

Proactive Monitoring: With real-time monitoring and threat detection, we stay one step ahead of cybercriminals, identifying and neutralizing risks before they become a danger.

Data Privacy Compliance: We prioritize data privacy and ensure that your sensitive information is safeguarded in compliance with industry standards and regulations.

Customized Solutions: Every business is unique, and our cybersecurity services are tailored to your specific requirements. Our experts work closely with you to devise a personalized defence strategy.

24/7 Support: Cyber threats never rest, and neither do we. Our dedicated team of security specialists is available round-the-clock to address any security concerns or emergencies.

Business Continuity: By securing your network data, we enable uninterrupted operations and safeguard your reputation in the face of potential cyber incidents.

Don’t wait for a cyber-attack to strike! Embrace the proactive approach to safeguarding your sensitive network data with our comprehensive cybersecurity solutions with CalibreQA. Partner with us today and ensure that your valuable assets remain protected from cyber threats, now and Into the future.

The post Safeguarding Your Sensitive Network Data with Unyielding Protection first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

The post Software security testing is crucial for all domains and industries first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.

The post Why Chaos testing trending in software industry now days first appeared on CalibreQA|Functional|Performance|Automation|CHAOS|Reliablity Testing|Mobile Application Testing.