How to Use JMeter for Performance & Load Testing-Chapter 5

Performance Testing is crucial to determine that the web application under test will satisfy high load requirements. It can be used to analyze overall server performance under heavy load.

Apache JMeter testing tool offers following benefit in Performance Testing

• JMeter can be used to test the performance of both static resources such as JavaScript and HTML, as well as dynamic resources, such as JSP, Servlets, and AJAX.
• JMeter can discover maximum number of concurrent users that your website can handle
• JMeter provides a variety of graphical analyses of performance reports.

JMeter Performance Testing includes:

• Load Testing: Modeling the expected usage by simulating multiple user access the Web services concurrently.
• Stress Testing: Every web server has a maximum load capacity. When the load goes beyond the limit, the web server starts responding slowly and produce errors. The purpose of the Stress Testing is to find the maximum load the web server can handle.

The figure below shows how JMeter load Testing simulates the heavy load:

Create a Performance Test Plan in JMeter

In this tutorial, we are doing a performance analysis of Google.com for 1000 users

Before testing the performance of target web application, we should determine-

• Normal Load: Average number of users visit your website
• Heavy Load: The maximum number of users visit your website
• What is your target in this test?

Here is the roadmap of this practical example

Step 1) Add Thread Group

1. Start JMeter
2. Select Test Plan on the tree
3. Add Thread Group

Right click on the "Test Plan" and add a new thread group: Add -> Threads (Users) -> Thread Group

In the Thread Group control panel, enter Thread Properties as follows:

• Number of Threads: 100 (Number of users connects to the target website: 100)
• Loop Count: 10 (Number of time to execute testing)
• Ramp-Up Period: 100

The Thread Count and The Loop Counts are different.

Ramp-Up Period tells JMeter how long to delay before starting the next user. For example, if we have 100 users and a 100-second Ramp-Up period, then the delay between starting users would be 1 second (100 seconds /100 users)

Step 2) Adding JMeter elements

Now we determine what JMeter elements in this test. The elements are

• HTTP request Default

This element can be added by right-clicking on the Thread Group and selecting: Add -> Config Element -> HTTP Request Defaults.

In the HTTP Request Defaults control panel, enter the Website name under test (http://www.google.com)

• HTTP Request

Right-click on Thread Group and select: Add -> Sampler -> HTTP Request.

In HTTP Request Control Panel, the Path field indicates which URL request you want to send to Google server.

For example, if you enter "calendar" in Path field. JMeter will create the URL request http://www.google.com/calendar  to Google server

If you keep the Path field blank  JMeter will create the URL request http://www.google.com to Google server.

In this test, you keep the Path field blank to make JMeter create the URL request http://www.google.com to Google server.

Step 3) Adding Graph result

JMeter can show the test result in Graph format.

Right click Test Plan, Add -> Listener -> Graph Results

Step 4) Run Test and get the test result

Press the Run button (Ctrl + R) on the Toolbar to start the software testing process. You will see the test result display on Graph in the real time.

The picture below presents a graph of a test plan, where we simulated 100 users who accessed on website www.google.com.

At the bottom of the picture, there are the following statistics, represented in colors:

• Black: The total number of current samples sent.
• Blue: The current average of all samples sent.
• Red: The current standard deviation.
• Green: Throughput rate that represents the number of requests per minute the server handled

Let analyze the performance of Google server in below figure.

To analyze the performance of the web server under test, you should focus on 2 parameters

• Throughput
• Deviation

The Throughput is the most important parameter. It represents the ability of the server to handle a heavy load.  The higher the Throughput is, the better is the server performance.

In this test, the throughput of Google server is 1,491.193/minute. It means Google server can handle 1,491.193 requests per minute. This value is quite high so we can conclude that Google server has good performance

The deviation is shown in red - it indicates the deviation from the average. The smaller the better.

Let compare the performance of Google server to other web servers. This is the performance test result of website http://www.yahoo.com/ (You can choose other websites)

The throughput of a website under test http://www.yahoo.com is 867.326/minutes. It means this server handle 867.326 requests per minute, lower than Google.

The deviation is 2689, much higher than Google (577). So we can determine the performance of this website is less than a Google server.

NOTE: The above values depend on several factors like current server load at Google, your internet speed, your CPU power etc. Hence, it's very unlikely that you will get the same results as above. 

Merge multiple JS/CSS files into one in Adobe AEM

Statement : How to merge multiple JS/CSS files into one 


Solution :

• In this example used proxy clientlibs approach, this is avail­able and rec­om­mend­ed since AEM6.2
• The AEM Client Library (or ClientLib) func­tion­al­i­ty will man­age all your JavaScript and CSS resources in your appli­ca­tion. It takes cares of depen­den­cy man­age­ment, merg­ing files and mini­fy­ing con­tent (remov­ing unnec­es­sary white spaces).

The fol­low­ing appli­ca­tion sce­nar­ios will be explained:

• mul­ti­ple com­po­nents with their own JavaScript and CSS files
• CSS resources have to go in the , JavaScript resources at the end of the page
• Resources need to be mini­fied
• chang­ing the mini­fi­ca­tion engine

Let’s get start­ed!

Step 1: Creating components and ClientLib nodes

First we make a few com­po­nents, in this exam­ple 3 com­po­nents are used, we do this all via CRXDE-lite (http://localhost:4502/crx/de).

Next we are going to add a “clientlib” node of type “cq:ClientLibraryFolder”, inside this node the JavaScript and CSS resources are stored.

Add a prop­er­ty to every “clientlib” node called “cat­e­gories” of type String[] with the sin­gle val­ue of “myproject.components” (to get a String[] type click the “Mul­ti” but­ton).

Now add a Boolean prop­er­ty “allow­Proxy”, and set this to true. This will make the clientlibs avail­able via the url /etc.clientlibs/, so it means they are not hav­ing the /apps ref­er­ence.

Your com­po­nents-fold­er will look now like this:

Step 2: Adding JavaScript and CSS resources

Now we are going to add some sim­ple JavaScript and CSS resources in the “clientlib” nodes.

Cre­ate fol­low­ing files inside of your “clientlib” fold­er of “MyFirst­Com­po­nent”:

first.css

.firstContainer {
    margin-top:10px;
}

first.js

/*
 * This is the comment of the function
 */
function getNameFirst() {
    // return the name
    return "some value";
}

js.txt

# mentions all the JavaScript resources of the ClientLib
first.js

css.txt

# mentions all the CSS resources of the ClientLib
first.css

And repeat the same thing for the oth­er com­po­nents to achieve some­thing that looks like this:

The con­fig­u­ra­tion of the com­po­nents are now fin­ished.

Step 3: Using ClientLibs in your component

Now the set­up of the ClientLib is fin­ished we can invoke the ClientLibs in your page com­po­nents. When you are using a JSP you can use cq:includeClientlib . In case you are using the HTML Tem­plate Lan­guage (HTL), you can use the data-sly-call to invoke the ClientLib. In this arti­cle HTL will be used for the exam­ples.

We start with putting the fol­low­ing into the ele­ment of our page:

The val­ue of the “cat­e­gories” prop­er­ties of the “clientlib” nodes are “myproject.components”, which is what we need to pro­vide above.

This results in the fol­low­ing HTML-out­put:

This has a few down­sides:

• 6 serv­er calls have to be made to fetch the resources.
• Appli­ca­tion struc­ture is exposed.

Step 4: Merging files

To merge the sev­er­al clientlib files into one, we define a clientlibs that is embed­ding the oth­er cat­e­gories. Exam­ple here is tak­en from /app­s/w­ere­tail/­clientlib­s/­clientlib-base.

Step 5: Dependencies

Anoth­er prop­er­ty you can add to the “clientlib” node is “depen­den­cies”, this way you can define depen­den­cies between ClientLibs.

Let’s add a depen­den­cy on “cq.jquery”:

When you now reload the page the depen­den­cy is writ­ten:

Step 6: Minify and Gzip

To deliv­er a bet­ter per­for­mance you can enable “Mini­fy” and “Gzip” for the “Adobe Gran­ite HTML Library Man­ag­er” (pre­vi­ous­ly also called “Day CQ HTML Library Man­ag­er”), in the Felix Con­fig­u­ra­tion con­sole (http://server/system/console/configMgr). These set­tings are rec­om­mend­ed for pro­duc­tion instal­la­tions.

By default the YUI com­pres­sor is used when mini­fy­ing files, you can bet­ter use the GCC (Google Clo­jure Com­pil­er) for this.

This is described here: https://helpx.adobe.com/experience-manager/kb/how-to-change-the-minification-engine-for-client-libraries-in-AEM.html

Common error with proxy clientlibs

When you use proxy clientlibs, then you may run into this error:

“Unable to proxy yourfont.ttf. No sup­port­ed type for .ttf”, this can hap­pen for types oth­er than JS/CSS.

Rea­son for this is that resources oth­er than JS/CSS need to be put into a fold­er called resources.

Exam­ple here on we-retail : https://​github​.com/​A​d​o​b​e​-​M​a​r​k​e​t​i​n​g​-​C​l​o​u​d​/​a​e​m​-​s​a​m​p​l​e​-​w​e​-​r​e​t​a​i​l​/​t​r​e​e​/​m​a​s​t​e​r​/​u​i​.​a​p​p​s​/​s​r​c​/​m​a​i​n​/​c​o​n​t​e​n​t​/​j​c​r​_​r​o​o​t​/​a​p​p​s​/​w​e​r​e​t​a​i​l​/​c​l​i​e​n​t​l​i​b​s​/​c​l​i​e​n​t​l​i​b​-​s​ite

FAQ

Q: I don’t want to have all my JavaScript ref­er­ences in the
A: Move the data-sly-call to the right loca­tion in your tem­plate, you can use ClientLib mul­ti­ple times

Q: Where are the gen­er­at­ed files stored in AEM?
A: They are stored in /var/clientlibs

Q: When devel­op­ing I want to have sin­gle file ref­er­ences in my HTML
A: Enable the debug-option in the HTML Library Man­ag­er

Q: Is there a con­sole so I can see the depen­den­cies?
A: Yes, look at this page http://server/libs/cq/ui/content/dumplibs.html

Q: Are there debug­ging options avail­able?
A: Yes, ?debugClientLibs=true writes out sin­gle files

Q: Can I rebuild the ClientLibs?
A: Yes, via this url: /libs/granite/ui/content/dumplibs.rebuild.html

Q: How can I use cache-bust­ing and ClientLibs?
A: You can enable the hash­ing of the url via ‘ver­sioned ClientLibs’.

Q: Do you have an exam­ple of this?
A: Yes, the “core” com­po­nents can be used as a reference: https://git.corp.adobe.com/CQ/aem-core-wcm-components

Q: What is the best prac­tice with regards to per­for­mance and caching
A: Via mod_expires / mod_deflate and the use of cache-bust­ing you can cache the css/js files on the brows­er to increase over­all per­for­mance of your pages. All of this will hap­pen in com­bi­na­tion with the dis­patch­er.

How to embed multiple categories.

In AEM, a category include will merge and compress all the files into a single js (or css) include. This is done per category include.

If you want to merge multiple categories, you should consider using the embed option in categories dependencies. How this works is:

1. Create a new category (for e.g. cq-embed)
2. Define embed dependencies ('cq.foundation-main','cq.shared') for the new category you have created.
3. Reference your new category.

Reference Article : http://blogs.adobe.com/experiencedelivers/experience-management/clientlibs-explained-example/

online tool to edit or extarct the .PSD,.PSB .PNG or .JPG

Statement - Online tools to edit or extarct the images, text, font styles form th ethe .PSD,.PDF and any other Image design files.

Solution :

1. Online Tools : https://studio.psdetch.com/ refer the below screenshot.
2. Click on start
3. click to Open to drop the design files as shown in below screenshot.

      

    

      4. you can extract, crop. color extract and  layer extraction...etc