Performance Testing Tools

Steps to create an NFS Mount for pods

2018-12-13T11:11:00.002+05:30

Steps to create an NFS Mount for pods

Perform the below steps on NFS Server:

In our case, the NFS is mounted on another different server. We have created a directory /MTCache and made the entry of the same in /etc/exports. The /etc/exports file on the NFS server contains the accessible NFS directories.

The entry in /etc/exports on the NFS hosting server will be:

/MTCache *(rw,sync,no_root_squash)

NFS Options:

Some options we can use in “/etc/exports” file for file sharing is as follows.

1. ro: With the help of this option we can provide read only access to the shared files i.e client will only be able to read.

2. rw: This option allows the client server to both read and write access within the shared directory.

3. sync: Sync confirms requests to the shared directory only once the changes have been committed.

4. no_subtree_check: This option prevents the subtree checking. When a shared directory is the subdirectory of a larger file system, nfs performs scans of every directory above it, in order to verify its permissions and details. Disabling the subtree check may increase the reliability of NFS, but reduce security.

5. no_root_squash: This phrase allows root to connect to the designated directory.

For more options with “/etc/exports“, you are recommended to read the man pages for export.

Update your export file by running below command:

#exportfs -a

Perform below steps on Master node of the OpenShift Cluster:

Persistent volumes (PVs) and persistent volume claims (PVCs) provide a convenient method for sharing a volume across a project.

Create two files nfs-pv.yaml and nfs-pvc.yaml.

Creating the Persistent Volume (nfs-pv.yaml)

apiVersion: v1

kind: PersistentVolume

metadata:

name: mtcachedir

spec:

capacity:

storage: 2Gi

accessModes:

- ReadWriteMany

persistentVolumeReclaimPolicy: Retain

nfs:

path: /MTCache

server: nfs.server

readOnly: false

Highlighted values are changes and has below significance:

name: mtcachedir : The name of the PV. This is the PV identity in various oc commands.

storage: 2Gi : The amount of storage allocated to this volume.

ReadWriteMany : accessModes are used as labels to match a PV and a PVC. Currently, no access rules are enforced based on the accessModes..

Retain : The volume reclaim policy Retain indicates that the volume will be preserved after the pods accessing it terminates. Valid Options are Retain (default) and Recycle.

nfs: : This defines the volume type being used, in this case the nfs plug-in.

/MTCache : This is the NFS mount path that is exported by the NFS Server.

nfs.server : This can be hostname or IP address of the NFS server.

Save the file with the changes and create the PV with below command:

# oc create -f nfs-pv.yaml

Verify that the PV was created:

# oc get pv

NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE

mtcachedir 2Gi RWX Retain Bound drop/mtcachedir 46m

Next step can be to create a PVC (nfs-pvc.yaml), which binds to the new PV:

A persistent volume claim (PVC) specifies the desired access mode and storage capacity. Currently, based on only these two attributes, a PVC is bound to a single PV. Once a PV is bound to a PVC, that PV is essentially tied to the PVC’s project and cannot be bound to by another PVC. There is a one-to-one mapping of PVs and PVCs.

apiVersion: v1

kind: PersistentVolumeClaim

metadata:

name: mtcachedir

spec:

accessModes:

- ReadWriteMany

resources:

requests:

storage: 2Gi

mtcachedir : sThis name is referenced by the pod under its volume section.

ReadWriteMany : Same as mentioned in PV.

2Gi : This claim looks for PVs offering 2Gi or greater capacity.

Save the file with the changes and create the PVC with below command:

# oc create -f nfs-pvc.yaml

Verify that the PVC was created:

# oc get pvc

NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE

mtcachedir Bound mtcachedir 2Gi RWX 56m

Creating the pod:

The main areas in the Pod Object Definition are as below:

volumeMounts:

enabled: true

items:

- name: mtcachedir

mountPath: /usr/bin/cache

volumes:

enabled: true

items:

- name: mtcachedir

persistentVolumeClaim:

claimName: mtcachedir

mountPath is the path as seen in the containers.

claimName is the name of PVC created above.

Save the pod file (nfs.yaml) and create the pod:

# oc create -f nfs.yaml

Pod should be up and running successfully.

Few errors which may be faced due are as below:

1. Warning FailedMount 1m kubelet, <server> Unable to mount volumes for pod "pod-user-0_drop(19240589-fe0b-11e8-a13c-005056a61c68)": timeout expired waiting for volumes to attach/mount for pod "drop"/"pod-user-0". list of unattached/unmounted volumes=[mtcachedir]

Sol: The above error may occur if the PV and PVC are not created. Create PV & PVC as suggested above and check.

2. mount.nfs: access denied by server while mounting nfs_server:/MTCache

you might have added the path in /etc/exports, but did not update the export with command:

#exportfs -a

The above error can further be confirmed by checking /var/log/messages. It may have the

rpc.mountd[7792]: refused mount request from nfs_client for /MTCache (/): not exported

More info can be found @ https://docs.openshift.com/enterprise/3.1/install_config/persistent_storage/persistent_storage_nfs.html#overview

SS command in Linux - more powerful than netstat

2018-08-30T18:34:00.000+05:30

Today i want to share a command ss (Socket statistics) to investigate network and debug tcp connections.

ss is used to dump socket statistics. It allows showing information similar to netstat. It can display more TCP and state information than other tools.

It is present in most of our Linux machines.

ss commands has lot of options. To get all options: ss -help

Few commands and outputs worth trying are as below:

ss -t ->stands for tcp. Gives information about tcp connections that are available on the system

#ss -t

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 352 172.19.79.104:ssh 172.29.155.168:64045

ESTAB 0 0 172.19.79.104:54550 172.19.79.105:pcsync-https

ESTAB 0 0 ::ffff:172.19.79.104:10250 ::ffff:172.19.79.105:47578

ss -ta ->a stands for all. Displays all tcp connections

#ss -ta

State Recv-Q Send-Q Local Address:Port Peer Address:Port

LISTEN 0 128 *:sunrpc *:*

LISTEN 0 128 127.0.0.1:domain *:*

LISTEN 0 5 10.104.10.1:domain *:*

LISTEN 0 5 172.18.0.1:domain *:*

LISTEN 0 5 192.168.122.1:domain *:*

LISTEN 0 5 172.19.79.104:domain *:*

LISTEN 0 128 *:ssh *:*

LISTEN 0 128 127.0.0.1:ipp *:*

LISTEN 0 100 127.0.0.1:smtp *:*

ESTAB 0 128 172.19.79.104:ssh 172.29.155.168:64045

ESTAB 0 0 172.19.79.104:54550 172.19.79.105:pcsync-https

Few other arguments are as below:

-t, --tcp display only TCP sockets

-S, --sctp display only SCTP sockets

-u, --udp display only UDP sockets

-d, --dccp display only DCCP sockets

-w, --raw display only RAW sockets

-x, --unix display only Unix domain sockets

Few important commands to try:

ss -tp -->processes show process using socket

E.g Output:

tcp ESTAB 0 0 172.19.79.105:http 172.19.48.200:31271 users:(("haproxy",pid=80305,fd=474))

It tells the service, processid and file-descriptor of the service that is using the socket.

ss -t4 -> to show only IPV4 sockets

-4, --ipv4 display only IP version 4 sockets

-6, --ipv6 display only IP version 6 sockets

ss -n --> numeric don't resolve service names

Example as below: 1433 port resolved as ms-sql-s port

# ss -tn

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 0 ::ffff:172.19.79.190:58096 ::ffff:172.19.76.75:1433

# ss -t

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 0 ::ffff:172.19.79.190:58096 ::ffff:172.19.76.75:ms-sql-s

ss -lt -->listening display listening sockets

# ss -lt

State Recv-Q Send-Q Local Address:Port Peer Address:Port

LISTEN 0 128 *:https *:*

LISTEN 0 128 *:pcsync-https *:*

LISTEN 0 128 *:pcsync-http *:*

LISTEN 0 128 127.0.0.1:10443 *:*

LISTEN 0 128 172.19.79.105:2379 *:*

# ss -ot

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 0 172.19.79.105:2379 172.19.79.105:33464 timer:(keepalive,16sec,0)

ESTAB 0 0 172.19.79.105:http 172.19.48.200:37659

ESTAB 0 0 172.19.79.105:http 172.19.48.200:12295

ESTAB 0 0 172.19.79.105:pcsync-https 10.104.12.26:45382 timer:(keepalive,2min8sec,0)

To get timer information about tcp connection.

Filtering with source or destination port

#ss -ot src :22

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 0 172.19.79.105:ssh 172.29.155.168:65332 timer:(keepalive,111min,0)

ESTAB 0 80 172.19.79.105:ssh 172.29.155.168:64465 timer:(on,1min28sec,10)

ESTAB 0 64 172.19.79.105:ssh 172.29.155.168:63503 timer:(on,594ms,0)

# ss -ot dst :443

State Recv-Q Send-Q Local Address:Port Peer Address:Port

ESTAB 0 0 10.104.12.1:53458 10.104.202.160:https timer:(keepalive,17sec,0)

ESTAB 0 0 10.104.12.1:49912 10.104.208.141:https timer:(keepalive,22sec,0)

ESTAB 0 0 10.104.12.1:38150 10.104.128.1:https timer:(keepalive,13sec,0)

ss -s ->show socket usage summary with breakdown

# ss -s

Total: 2829 (kernel 3087)

TCP: 2221 (estab 2086, closed 82, orphaned 0, synrecv 0, timewait 37/0), ports 0

Transport Total IP IPv6

* 3087 - -

RAW 0 0 0

UDP 27 14 13

TCP 2139 2103 36

INET 2166 2117 49

FRAG 0 0 0

Initial basic checks before proceeding to DB tunings in MSSQL

2018-05-16T19:24:00.001+05:30

Initial basic checks before proceeding to DB tunings in MSSQL:

Check your SQL Server environment before tuning for performance

Sometimes when we have issues with slow response for our DB queries, we think of tuning the query assuming the SQL Server is tuned and it may be problem with queries. But it is observed that it is better to make a common practice to check the basic configuration settings of the SQL server before we start to analyze the queries deeper. Today i will try to touch base some of those settings which we always need to check for proper settings of the SQL server Environment.

Check 1: Database and Transaction log files on separate drives

To obtain optimal SQL performance, it is recommended to separate the data and the log files onto separate physical drives. Placing both data AND log files on the same device can cause contention for that device, resulting in poor performance. Placing the files on separate drives allows the I/O activity to occur at the same time for both the data and log files. Read I/O for database files is typically random when reading database pages while I/O for the transaction log is typically sequential.

We have observed huge difference in data reconciliation batch jobs after separating database and transaction log files on separate drives.

As in below snap, the Data files are located on D:\ drive and Log files are on E:\ drive.

Check 2: Check server Memory settings

Check for the memory settings, were they changed from default values? The default setting for min server memory is 0 and for max server memory it is 2,147,483,647 megabytes (MB) = 2.14 Petabyte. By default, SQL Server can change its memory requirements dynamically based on available system resources.

In case these values are changed from default to restrict on consumption, analyze further whether the server is dedicated to Database or shared with any other application? Is the DB server hosting single instance or multiple instances? More details to set can be found@

https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/server-memory-server-configuration-options?view=sql-server-2017

Server memory options (default values) as below:

We observed in one of our customer issues, where the customer unknowingly changed the default values to restrict and observed high response times in query executions. When the settings were changed to default the issue got resolved.

Check 3: Check Log Files

Always leave enough free space and drive of the transaction log file is not overloaded for your normal operations to occur with required IOPS and low latency without forcing an auto-grow operation. Transaction log file contains log records produced during the logging process in a SQL Server database. The transaction log is the most important component of a SQL Server database when it comes to the disaster recovery.

Auto-grow even is one of the biggest performance intensive operations. Growing the log file can be extremely time-consuming. It can force any DML operations to wait until the growth is complete before the operation can proceed. By making sure that we have plenty of free space on the drive of the transaction log file, you can avoid these performance hits altogether.

Check 4: Check for parallelism settings

SQL Server can take advantage of a server's multiple processors. It's able to take some operations and to spread the processing across the processors available to it, with the goal of dividing the work into smaller chunks so that the overall operation performs quicker. There are a couple of instance-wide settings that determine if, or when, the optimizer might generate "parallel execution plans."

Max degree of parallelism, which determines the maximum number of processors that SQL Server can use when executing a parallel query; by default this is set to "0,"which means that all available processors can potentially be used to execute a query.

Cost threshold for parallelism, which specifies the threshold, or minimum cost, at which SQL Server creates and runs parallel plans; this cost is an estimated number of seconds in which the query will run, and the default value is "5." In other words, if the query optimizer determines that a query will take less than 5 seconds to execute, then it won't consider using parallelism.

Note: There is no hard and fast rule for determining when parallelism may be useful, or when it will be costlier. The best approach is to observe the execution times and wait states of queries that use parallelism, and where necessary, either change the system settings to increase the cost threshold.

Example of settings done in our Database, after some many test we found these setting appropriate to our Environment.

Note: This is a dedicated DB server with 20 core CPU.

Check 5: Check for Parameterization:

SQL Server provides two types of query parameterization: “Simple” and “Forced”. The “Parameterization” property controls the way SQL Server handles literals in query predicates. In some cases, SQL Server might decide to replace a literal value with a parameter during query optimization.

The default value is “Simple”. With “Simple”, SQL Server will only parameterize queries when it is certain that there is only one plan for the query regardless of the value of the literal being parameterized.

When set to FORCED PARAMETERIZATION, any literal value that appears in a SELECT, INSERT, UPDATE or DELETE statement submitted in any form is converted to a parameter during query compilation.

We set the Parameterization to SIMPLE under Miscellaneous setting in Options.

Linux tuning while running huge load using Jmeter

2017-07-25T17:54:00.003+05:30

While running our jmeter load tests on Unix box with a target of 2500 User Load we got the exception “Non HTTP response code: java.net.NoRouteToHostException,Non HTTP response message: Cannot assign requested address” in jmeter log

We have set open files limit to 50000 and ran the test, but still we were getting the errors.

$ ulimit -a

core file size (blocks, -c) 0

data seg size (kbytes, -d) unlimited

scheduling priority (-e) 0

file size (blocks, -f) unlimited

pending signals (-i) 31182

max locked memory (kbytes, -l) 64

max memory size (kbytes, -m) unlimited

open files (-n) 50000

pipe size (512 bytes, -p) 8

POSIX message queues (bytes, -q) 819200

real-time priority (-r) 0

stack size (kbytes, -s) 8192

cpu time (seconds, -t) unlimited

max user processes (-u) 4096

virtual memory (kbytes, -v) unlimited

file locks (-x) unlimit

Error in Jmeter Log file :

1487747366269,9,GET /sample/,Non HTTP response code: java.net.NoRouteToHostException,Non HTTP response message: Cannot assign requested address,Thread Group 1-30,text,false,Test failed: text expected to contain /Logout/,2128,738,738,0,0

1487747366276,2,GET /sample/,Non HTTP response code: java.net.NoRouteToHostException,Non HTTP response message: Cannot assign requested address,Thread Group 1-297,text,false,Test failed: text expected to contain /Logout/,2128,738,738,0,0

1487747366279,2,GET /sample/,Non HTTP response code: java.net.NoRouteToHostException,Non HTTP response message: Cannot assign requested address,Thread Group 1-630,text,false,Test failed: text expected to contain /Logout/,2128,738,738,0,0

1487747366279,2,GET /sample/,Non HTTP response code: java.net.NoRouteToHostException,Non HTTP response message: Cannot assign requested address,Thread Group 1-272,text,false,Test failed: text expected to contain /Logout/,2128,738,738,0,0

On Unix machine we performed the below steps for debug and resolution:

We see that all the local ports are occupied with TIME_WAIT or ESTABLISHED.

Output:

817 TIME_WAIT

28046 ESTABLISHED

Checked for the Local Port range:

$ cat /proc/sys/net/ipv4/ip_local_port_range

32768 60999

Resolution:

1. Increased the local port range using below command:

echo 1024 65000 > /proc/sys/net/ipv4/ip_local_port_range

This allows more local ports to be available.

2. Enable fast recycling TIME_WAIT sockets as below:

$ sudo sysctl -w net.ipv4.tcp_tw_recycle =1

By default,

cat /proc/sys/net/ipv4/tcp_tw_recycle

Output : 0 (disabled by default)

Be cautious if enabled in production environments, since this is our internal Environment and machine used only for Jmeter load tests, we enabled recycle and resolved the issue.

3. Enable reuse of sockets as below:

$ sudo sysctl -w net.ipv4.tcp_tw_reuse=1

By default,

cat /proc/sys/net/ipv4/tcp_tw_reuse

Output : 0 (disabled by default)

Note: The tcp_tw_reuse setting is particularly useful in environments where numerous short connections are open and left in TIME_WAIT state, such as web servers. Reusing the sockets can be very effective in reducing server load.

After enabling fast recycling and reuse the server could support 5K user Load with single Unix box.

Note: The Load test was targeted for Login/Logout tests and not a heavy workload tests.

Starting Perfmon on all Windows machines with a single Batch file

2017-01-20T19:06:00.001+05:30

In one of our project we have more than 4 Windows servers. We use perfmon to monitor the resource utilization. Each time we run load test we start the perfmon on all the servers.
So created the below batch file to do the job.

The batch file does the below:

Create a directory with current date and time
Start perfmon on all 4 AR servers
Wait for 1 hr
Copy the result file (.csv) from each server into the director created in step1.
Stop perfmon on all 4 AR servers.

@echo off

for /f %%I in ('wmic os get localdatetime ^|find "20"') do set dt=%%I

REM dt format is now YYYYMMDDhhmmss...

REM set dt=%dt:~4,2%-%dt:~2,2%-%dt:~0,4%

set dt=%dt:~6,2%%dt:~4,2%%dt:~2,2%%dt:~8,2%%dt:~10,2%

echo %dt%

mkdir D:\Perfmon\Perfmon_%dt%

logman start "Counter" -s server1

logman start "Counter" -s server2

logman start "Counter" -s server3

logman start "Counter" -s server4

timeout /t 3600

copy \\server1\c$\PerfLogs\Admin\Counter\*%dt%*.csv D:\Perfmon\Perfmon_%dt%\.

copy \\server2\c$\PerfLogs\Admin\Counter\*%dt%*.csv D:\Perfmon\Perfmon_%dt%\.

copy \\server3\c$\PerfLogs\Admin\Counter\*%dt%*.csv D:\Perfmon\Perfmon_%dt%\.

copy \\server4\c$\PerfLogs\Admin\Counter\*%dt%*.csv D:\Perfmon\Perfmon_%dt%\.

logman stop "Counter" -s server1

logman stop "Counter" -s server2

logman stop "Counter" -s server3

logman stop "Counter" -s server4

Note: The Data collector with name "Counter" is already added or created in perfmon under "Data Collector Sets"-> "User Defined" on all the servers.
Note: The .csv file created was ending with ddMMyyyyhhmm format.

Beaware!!! with NewRatio while using Concurrent Mark Sweep GC as Garbage Collector

2016-12-24T07:07:00.002+05:30

In Sun JDK there were few bugs previously with subject “JDK-6872335 : NewRatio ignored when UseConcMarkSweepGC set”.

http://bugs.java.com/view_bug.do?bug_id=6872335

http://bugs.java.com/view_bug.do?bug_id=6862534

Although these bugs are fixed, but IMO the bug still exists for default settings of NewRatio when UseConcMarkSweepGC is used.

We still have the bug where the default NewRatio=2 is not considered along with UseConcMarkSweepGC

Option #1 : Default GC (-XX:+UseParallelGC) : PSYoungGen total 1835008K = 1.75GB (As it considered the default NewRatio=2)

# /usr/bin/java -server -Xms6144m -Xmx6144m -XX:MaxMetaspaceSize=256m -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -version

-XX:InitialHeapSize=6442450944 -XX:MaxHeapSize=6442450944 -XX:MaxMetaspaceSize=268435456 -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseParallelGC

java version "1.8.0_60"

Java(TM) SE Runtime Environment (build 1.8.0_60-b27)

Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)

Heap

PSYoungGen total 1835008K, used 94372K [0x0000000740000000, 0x00000007c0000000, 0x00000007c0000000)

eden space 1572864K, 6% used [0x0000000740000000,0x0000000745c29180,0x00000007a0000000)

from space 262144K, 0% used [0x00000007b0000000,0x00000007b0000000,0x00000007c0000000)

to space 262144K, 0% used [0x00000007a0000000,0x00000007a0000000,0x00000007b0000000)

ParOldGen total 4194304K, used 0K [0x0000000640000000, 0x0000000740000000, 0x0000000740000000)

object space 4194304K, 0% used [0x0000000640000000,0x0000000640000000,0x0000000740000000)

Metaspace used 2189K, capacity 4480K, committed 4480K, reserved 1056768K

class space used 240K, capacity 384K, committed 384K, reserved 1048576K

[root@vl-aus-sln-pt39 ~]#

Option #2 : UseConcMarkSweepGC only (-XX:+ UseConcMarkSweepGC) : par new generation total 153344K = 149.75 MB (Here –XX:NewRatio=2 is ignored which is set by default)

# /usr/bin/java -server -Xms6144m -Xmx6144m -XX:MaxMetaspaceSize=256m -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseConcMarkSweepGC -version

-XX:InitialHeapSize=6442450944 -XX:MaxHeapSize=6442450944 -XX:MaxMetaspaceSize=268435456 -XX:MaxNewSize=174485504 -XX:MaxTenuringThreshold=6 -XX:NewSize=174485504 -XX:OldPLABSize=16 -XX:OldSize=348971008 -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseConcMarkSweepGC -XX:+UseParNewGC

java version "1.8.0_60"

Java(TM) SE Runtime Environment (build 1.8.0_60-b27)

Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)

Heap

par new generation total 153344K, used 8179K [0x0000000640000000, 0x000000064a660000, 0x000000064a660000)

eden space 136320K, 6% used [0x0000000640000000, 0x00000006407fcf00, 0x0000000648520000)

from space 17024K, 0% used [0x0000000648520000, 0x0000000648520000, 0x00000006495c0000)

to space 17024K, 0% used [0x00000006495c0000, 0x00000006495c0000, 0x000000064a660000)

concurrent mark-sweep generation total 6121088K, used 0K [0x000000064a660000, 0x00000007c0000000, 0x00000007c0000000)

Metaspace used 2190K, capacity 4480K, committed 4480K, reserved 1056768K

class space used 240K, capacity 384K, committed 384K, reserved 1048576K

[root@vl-aus-sln-pt39 ~]#

Option #3 : UseConcMarkSweepGC along with NewRatio=2 (-XX:+ UseConcMarkSweepGC –XX:NewRatio=2) : par new generation total 1887488K = 1.8 GB (Here –XX:NewRatio=2 is considered when set explicitly)

# /usr/bin/java -server -Xms6144m -Xmx6144m -XX:MaxMetaspaceSize=256m -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseConcMarkSweepGC -XX:NewRatio=2 -version

-XX:InitialHeapSize=6442450944 -XX:MaxHeapSize=6442450944 -XX:MaxMetaspaceSize=268435456 -XX:MaxTenuringThreshold=6 -XX:NewRatio=2 -XX:OldPLABSize=16 -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseConcMarkSweepGC -XX:+UseParNewGC

java version "1.8.0_60"

Java(TM) SE Runtime Environment (build 1.8.0_60-b27)

Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)

Heap

par new generation total 1887488K, used 100669K [0x0000000640000000, 0x00000006c0000000, 0x00000006c0000000)

eden space 1677824K, 6% used [0x0000000640000000, 0x000000064624f7f0, 0x00000006a6680000)

from space 209664K, 0% used [0x00000006a6680000, 0x00000006a6680000, 0x00000006b3340000)

to space 209664K, 0% used [0x00000006b3340000, 0x00000006b3340000, 0x00000006c0000000)

concurrent mark-sweep generation total 4194304K, used 0K [0x00000006c0000000, 0x00000007c0000000, 0x00000007c0000000)

Metaspace used 2189K, capacity 4480K, committed 4480K, reserved 1056768K

class space used 240K, capacity 384K, committed 384K, reserved 1048576K

[root@vl-aus-sln-pt39 ~]#

Set the New Ratio explicitly if we are using ConcMarkSweepGC .

To Obtain GC details from running java process whithout adding the GC monitoring parameters in jvm args

2016-12-24T06:49:00.000+05:30

Just wanted to share a tool for GC Monitoring.

If you’ve forgotten to enable GC logging, or wanted to monitor GC in the middle of the load test, there is a good substitute to watch how GC operates over time.

jstat is the tool of choice. jstat can provide good visibility into GC for a live program. jstat provides nine options to print different information about the heap; jstat -options will provide the full list.

One useful option is -gcutil, which displays the time spent in GC as well as the percentage of each GC area that is currently filled. Other options to jstat will display the

GC sizes in terms of KB.

jstat takes an optional argument—the number of milliseconds to repeat the command—so it can monitor over time the effect of GC in an application.

Syntax : jstat -gcutil <pid> <Milli Sec to repeat>

Here is some sample output repeated every second:

Ø jstat -gcutil 90776 1000

S0 S1 E O M CCS YGC YGCT FGC FGCT GCT

80.52 0.00 12.98 45.07 95.85 91.20 4808 296.955 42 18.608 315.563

When monitoring started, the program had already performed 4808 collections of the young generation (YGC), which took a total of 296.955 seconds (YGCT). It had also performed

42 full GCs (FGC) requiring 18.608 seconds (FGCT); hence the total time in GC (GCT) was 315.563 seconds.

Since the sample was taken after the no load test and since there is no active load, so the readings were same.

All three sections of the young generation are displayed here: the two survivor spaces (S0 and S1) and eden (E). Then old generation (O) and MetaSpace (M).

Command to obtain complete details of a process running in windows

2016-12-23T17:08:00.001+05:30

Just wanted to share a command in Windows, to obtain complete details of the processes running in windows.

In Unix/Linux we use the below command to obtain all the java processes running on particular server:

ps -ef|grep java

which shows the PID, command line and other details.

The same can be obtained in windows OS.

Using Task Manager to show the command line option, the display value is so long that the CLASSPATH setting gets cut off and complete details are not obtained.

To show the entire command line including switches/options is to use the WMIC command:

C:\> WMIC process where caption="java.exe"

Open an windows CMD prompt, execute the following "Windows Management Instrumentation Command-line" (WMIC):

To obtain processid and commandline provide the arguments as get

C:\> WMIC process where caption="java.exe" get processid,commandline

Note: You can pipe the result out to a file like below: (Open cmd prompt as Run as Administrator)

C:\> WMIC process where caption="java.exe" get processid,commandline > C:\TEMP\OUTPUT.TXT

There are different other fields like :

PageFaults, PageFileUsage, ParentProcessId, PeakPageFileUsage, PeakVirtualSize, PeakWorkingSetSize, Priority, PrivatePageCount, ProcessId, QuotaNonPagedPoolUsage, QuotaPagedPoolUsage, QuotaPeakNonPagedPoolUsage, QuotaPeakPagedPoolUsage, ReadOperationCount, ReadTransferCount, SessionId, Status, TerminationDate, ThreadCount, UserModeTime, VirtualSize, WindowsVersion, WorkingSetSize, WriteOperationCount, WriteTransferCount

Database Test Plan with JMeter

2015-10-07T17:14:00.001+05:30

Let us see how we can test the database in Jmeter using JDBC Request Sampler.

In this tutorial we will use oracle jdbc driver.

Required jar E.g. “ojdbc6.jar” is placed in <JMETER_Path>/lib.

Prepare a Test Plan as shown below:

Here we have added:

User Defined Variables – Defined the required parameters for Database Connection
JDBC Connection Configuration
Thread Group
JDBC Request under Thread Group
BeanShell Sampler – To display the output of the JDBC Request.
View Results Tree – To View the Results

JDBC Request Sampler is used to send an JDBC Request to database. But before using this we need to setup the required JDBC connection and it is done via JDBC Connection Configuration element.

Under JDBC Connection Configuration we have the below defined values:

We defined the Variable Name as “JDBC_Pool”. The values required for Database Connection are defined in User Defined Variables and are used here.

E.g:

jdbc_url = jdbc:oracle:thin:@DB_Server:port:DB_Instance

jdbc_driver = oracle.jdbc.OracleDriver

jdbc_user = User to connect to DB. E.g. sa

jdbc_pass = Password for the above user

Under JDBC request we have the below values:

The Variable Name should be same as that of Variable Name of JDBC Connection Configuration.

We have different type of Query types as below:

In our example we selected “Select Statement” as Query type.

In the Query section, write the exact SQL query for execution

Under Variable names : Define a variable e.g. sql_var.

Note: This field can contain a comma-separated list of variable names to hold values returned by Select statements, Prepared Select Statements or CallableStatement.

Under BeanShell Sampler we wrote below line to display the records in the Log Viewer.

Run the Test and view the results have the below output:

If we view the result, it took a significant time ~ 6mins to process the JDBC Request.

Using a Custom Jar in BeanShell Sampler in Jmeter

2015-10-07T12:56:00.001+05:30

Let us see an example on how we can use a custom Java classes and methods in JMeter BeanShell sampler.

Outline of the steps:

Write Java classes and methods in IDE tools like Eclipse or NetBeans
Create a Jar of the above project
Import the Jar to JMeter location
Use the Java method in Jmeter BeanShell sampler
Run the test plan and check results

Let us see the above step by step:

For getting the concepts clear, let us create an example class which will generate factorial of a given number. The number will also be a random number.

Let us create a class containing the method to calculate a factorial and this will be used in JMeter. I created the method as below in eclipse.

Here we have created new project “FactorialJar”. Under the project, we created two projects named as “FactClass” and “TestFact”. Under each class we created a Class called “Fact” and “Facttest”.

Code for Fact.java is as below:

package FactClass;

public class Fact {

public int facto(int f)

{

int fact=1;

for(int i=1;i<=f;i++)

fact=fact*i;

return fact;

}

Code for Facttest.java is as below:

package TestFact;

import FactClass.Fact;

public class Facttest {

public static void main(String[] args) {

Fact fac = new Fact();

int res=fac.facto(4);

System.out.println("Factorial =" + res);

}

Once completed, run the project and verify the code is working as expected. The Factorial for 4 should be displayed. The output will be as below in Eclipse:

Factorial =24

Create a Jar of the above project

To create a JAR from the project, right click on the project and select Export… and choose JAR file option under Java drop down.

Click on Next and select the JAR file location and name the jar as “Facto.jar”. Click on Finish.

The “Facto.jar” will be created at the above mentioned location.

Import the Jar to JMeter location

Copy the JAR from the JAR location mentioned above.

Paste the JAR into Jmeter Path : <JMeter Path>/lib/ext folder.

Relaunch the JMeter GUI

Use the Java method in Jmeter BeanShell sampler

Let us create a TestPlan as shown below:

Random Variable is defined as below:

The BeanShell sampler code is as below:

import FactClass.Fact;

Fact fac = new Fact();

int result=fac.facto(Integer.parseInt(vars.get("num")));

vars.put("result",result.toString());

print("Factorial of " + vars.get("num") + " = " + vars.get("result"));

log.info("Factorial of " + vars.get("num") + " = " + vars.get("result"));

Run the test plan and check results

Run the test plan and it will generate the factorial of a random number between 1-10.

The output is as below:

We have the output in the Log Viewer and Console as below

How to use a value between two different threads in Jmeter

2015-09-29T12:39:00.001+05:30

How to use a value between two different threads:

Let us see how we can use the extracted value in one thread can be used in a different thread:

As shown below we have Two threads (Thread Group – 1 and Thread Group -2). Under Thread Group -1 we have a HTTP Request where we extracted Request_Id and Session_Id. In our example we will use the same Ids in Thread Group -2

We have BeanShell PostProcessor to log the output of the variables in the output log.

The Lines in the both BeanShell is as below:

log.info("Request Id in Thread 1 = " + "${Request_Id}");

log.info("Session Id in Thread 1 = " + "${Session_Id}");

Now if we run the Script we get the below output:

As we see the values of both the IDs are not passed to Thread Group-2.

Now we will add few lines in the BeanShell PostProcessor as below and run again:

${__setProperty(Request_Id,"${Request_Id}")};

${__setProperty(Session_Id,"${Session_Id}")};

log.info("Request Id in Thread 2 = " + ${__P(Request_Id)});

log.info("Session Id in Thread 2 = " + ${__P(Session_Id)});

As we see the values are passed to Thread Group -2.

Few lines on : ${__setProperty(Request_Id,"${Request_Id}")};

__setProperty() – The setProperty function sets the value of a JMeter property and is a Jmeter built-in function. Detail here

Request_Id – name of the property that will be set.

${ Request _ Id} – Value of the property and is the variable that was referred to as in Regular Expression Extractor.

This is the line that is responsible for transferring the value between threads. Now we can access the value of ${ Request _ Id} from any other thread group.

Note: Properties are not the same as variables. Variables are local to a thread; properties are common to all threads, and need to be referenced using the __P or __property function.

Point to note:

Sometimes it may happen that Thread Group-2 will run before Thread Group -1. Then we will not get the required result. Example is as shown in below screenshot:

Here Thread Group-2 ran before Thread Group-1, so the variables for ThreadGroup-2 are not set.

To avoid such situation we need to check the option “Run Thread Groups consecutively” option under Test Plan as shown below:

Tuning JDBC Data Sources Connection Pool in WebLogic

2015-09-04T17:48:00.001+05:30

Tuning JDBC Data Sources Connection Pool in WebLogic:

While we are Load testing Web services with our application deployed on WebLogic Server Version: 10.3.6.0 most of transactions started failing and when checked in the logs we found the below exception:

####<28.08.2015 17:32:54 MSK> <Info> <Common> <server.com> <clust1> <[ACTIVE] ExecuteThread: '50' for queue: 'weblogic.kernel.Default (self-tuning)'> <internal> <BEA1-17FBAA30098FE2C54C98> <> <1439904774589> <BEA-000627> <Reached maximum capacity of pool "AppDataSource", making "0" new resource instances instead of "1".>

####<28.08.2015 17:32:54 MSK> <Error> <server.com> <clust1> <[ACTIVE] ExecuteThread: '82' for queue: 'weblogic.kernel.Default (self-tuning)'> <guest> <> <> <1439904774589> <BEA-000000> <ERROR wf - WfSubscriberSysJMSBean.onMessage:

WF Engine detected error:

com.App.Exception: java.security.PrivilegedActionException: java.rmi.RemoteException: EJB Exception: ; nested exception is:

<……Error Stack>

Caused by: com.app.framework.jdbc.DataAccessException: Error due to access to database:

<…. Error Stack>

Caused by: weblogic.jdbc.extensions.PoolLimitSQLException: weblogic.common.resourcepool.ResourceLimitException: No resources currently available in pool AppDataSource to allocate to applications, please increase the size of the pool and retry..

at weblogic.jdbc.common.internal.JDBCUtil.wrapAndThrowResourceException(JDBCUtil.java:252)

at weblogic.jdbc.jts.Driver.newConnection(Driver.java:938)

at weblogic.jdbc.jts.Driver.createLocalConnection(Driver.java:336)

at weblogic.jdbc.jts.Driver.connect(Driver.java:173)

at weblogic.jdbc.common.internal.RmiDataSource.getConnectionInternal(RmiDataSource.java:533)

at weblogic.jdbc.common.internal.RmiDataSource.getConnection(RmiDataSource.java:498)

at weblogic.jdbc.common.internal.RmiDataSource.getConnection(RmiDataSource.java:491)

at com.App.framework.jdbc.JDBCTemplates.execute(JDBCTemplates.java:130)

... 25 more

We have the below values set for JDBC data pool settings:

<initial-capacity>10</initial-capacity>

<max-capacity>35</max-capacity>

As we see in the above screenshot all the 35 were occupied when test was running. So the exception is obvious.

We need to increase the JDBC Connection Pool.

So before increasing the number to some random number we re-calculated the required capacity based on required work manager threads.

In work managers we have types defined are as following :

Work Manager, Fair Share Request Class and Maximum Threads Constraint.

More information on work managers can be found at http://docs.oracle.com/cd/E17904_01/web.1111/e13701/self_tuned.htm#CNFGD112

For MaxThreadsConstraint the count is set to 25 as below. Also same is set for two more work managers

For XA DataSource:

The simple approach to sizing the pool is to set the initial/minimum capacity to the maximum capacity. Doing this creates all connections at startup, avoiding creating connections on demand and the pool is stable.

So the initial-capacity is set equal to max-capacity. Both are set to 80.

We have in total 21 work Managers configured. Out of 21, 3 are MaxThreadConstaints. So calculation is done as below:

(MaxThreadsConstraint (25) + widgetJobsMaxThreadsConstraint(16) + widgetCancelJobsMaxThreadsConstraint (4)) * 1.2 + 18 (Work Manager, Fair Share Request Class) = 72 connection to take a small margin 80.

Equality initial-capacity = max-capacity is also driven by the desire to reduce the cost base in create / delete / shrink connections in the pools.

In WLS 10.3.6, minimum capacity is used to specify the lower limit to which a pool will shrink. If minimum capacity is not set, it defaults to the initial capacity for upward compatibility.

So we have initial-capacity = max-capacity = min-capacity = 80

More details on data source connection pool sizing can be found at https://blogs.oracle.com/WebLogicServer/entry/data_source_connection_pool_sizing

So we have below settings:

For Non-XA data source the settings are as below:

Increased from 5 to 15

Also in all descriptors, data sources are necessary to register two additional parameters designed to protect the stability of the Productions in the future from a different kind of problem.

The two parameters added are as below:

<internal-properties>

<name>CountOfRefreshFailuresTillDisable</name>

</property>

<name>CountOfTestFailuresTillFlush</name>

</property>

</internal-properties>

CountOfRefreshFailuresTillDisable

Specifies the number of reconnect failures allowed before WebLogic Server disables a connection pool to minimize the delay in handling the connection request caused by a database failure. Zero means it is disabled. Default value is 2

CountOfTestFailuresTillFlush

Specifies the number of test failures allowed before WebLogic Server closes all unused connections in a connection pool to minimize the delay caused by further database testing. Zero means it is disabled. Default value is 2

After running the test with these settings we no more have the “weblogic.jdbc.extensions.PoolLimitSQLException” in the logs

Running Load Test in Jmeter for Webservices

2015-09-03T13:15:00.001+05:30

Once we have completed the scripting for required flows. We need to design a scenario according to the NFRs and execute the test in Jmeter to obtain results for our Load test.

Let us see how this can be achieved in Jmeter for the previously webservices with 4 threads to be Load tested.

Creation of the Scenario file and defining them in the Thread group:

Let us create a Scenario.csv file with below details and save it.

sc0=0_DataFolder:1_NumberOfThreads:2_RampUp_sec:3_LoopCount:4_Duration_sec:5_StartUpDelay_sec:6_UserThinkTime_ms:7_Throughput_spm

sc1=SC1_1USR:1:30:1:36000:0:1000:2.5

sc2=SC2_5USR:1:30:1:36000:60:1000:1.67

sc3=SC3_1USR:1:30:1:36000:120:1000:1.2

sc4=SC4_5USR:1:30:1:36000:240:1000:5.1

The above file is a csv file which has details of the following:

0_DataFolder : where the xml files and csv files required are kept

1_NumberOfThreads : Defines the number of users.

2_RampUp_sec : value for the Ramp-up Period (in Sec).

3_LoopCount : value for LoopCount

4_Duration_sec : value for Duration (Sec) under Scheduler

5_StartUpDelay_sec : value for Startup delay (Sec) under Scheduler

The above values #1 to #5 will be referenced under Thread properties of Thread Group as below:

Note:

Under Scheduler we have the below:

Start Time

An absolute start time is given here. When you start your test, JMeter will wait until the specified start time to begin testing. The Startup Delay field over-rides Start Time

End Time

An absolute end time is given here. When you start your test, JMeter will wait until the specified start time to begin testing, and it will stop at the specified end time. The Duration field over-rides End Time

Duration (seconds)

We can choose a relative end time using this field. JMeter will use this to calculate the End Time, and ignore the End Time value.

Startup delay (seconds)

We can choose a relative startup delay using this field. JMeter will use this to calculate the Start Time, and ignore the Start Time value.

6_UserThinkTime_ms : value for think time

7_Throughput_spm : value for throughput. This value is determined according to NFR.

E.g: 2.5 is the defined value in sc1. So transactions in hour will be:

2.5*60 = 150. This xml will be injected 150 times in duration of 1hr test.

This value is referred in “Constant Throughput Timer” as below:

The below lines for example are added in the BeanShell sampler which is under “Only Once Controller”

vars.put("scId",String.valueOf(vars.get("sc1")).split(":")[0]);

vars.put("scThinkTime",String.valueOf(vars.get("sc1")).split(":")[6]);

vars.put("scThroughput",String.valueOf(vars.get("sc1")).split(":")[7]);

Creation of the Test Plan:

The overall test plan is as below:

Note: We have used “jp@gc - Variables From CSV File” plugin to read the values from the scenario.csv which is created in Step#1.

This plugin can be obtained from http://jmeter-plugins.org/

All other components which are added in the test plan are self-explanatory.

Execution of the Test Plan:

We can run the test plan either using Jmeter GUI or as Non-GUI mode:

Jmeter GUI mode:
Just click on Start button in the toolbox (or)
Menu Run - > Start (or)
Ctrl+R will run the Load Test

To start test using command line (Non-GUI mode):

Just enter the below command from Jmeter/bin folder.

~\JMeter\apache-jmeter\bin>jmeter -n -t "~\Tests\JMX\LoadTest.jmx" -l "~\Logs\GenerateLog.jtl"

WebServices LoadTesting Using Jmeter - Part 2

2015-08-24T17:02:00.001+05:30

In Previous post we mentioned that “In case there is change in the XML we need to modify the SOAP/XML-RPC Request everytime.”

Also, if in case we want to create some different orders with different prefixes then we need to add different threads and in that case if the xml is changed, we need to modify the xml in all the Xmls.

We can overcome such situations by keeping the xml at a location which can be accessed by the thread when ran. Only one xml can be modified for any changes without updating them on each request.

Let’s proceed with the steps

The xml is saved at certain location with name as “order.xml”
Add a “Once Only Controller” to the Thread Group. Add a BeanShell sampler to the controller.
Simple code in BeanShell sampler to read the required xml as below:

The above step read the order.xml and stored it in OrderXML.

We wrote a function readxmlFile which can be used to read any xml file and store for further modifications.

4. Add another “BeanShell Sampler” to the Thread Group for parameterizing the xml.

5. The code for modification is as below:

Note: The variables in the xml as modified for e.g. #LOCATION_ID# instead of ${ LOCATION_ID} as in previous posts.

6. In the SOAP/XML-RPC Request, just mention the XML as parameter as below:

We will have the overall TestPlan as below:

WebServices LoadTesting Using Jmeter

2015-08-12T18:42:00.001+05:30

Before starting Jmeter Webservices testing we need to keep below information handy for :

1. XML/XMLs required for the flow

2. URL where the SOAP/XML-RPC Request

Let us Create a new order using webservice:

1. Create a Test Plan

2. Add a Thread Group

3. Add Sampler -> SOAP/XML-RPC Request as shown below:

SOAP/XML-RPC Request sampler sends a SOAP request to a webservice. It can also be used to send XML-RPC over HTTP.

4. Fill the required details in URL and SOAP/XML-RPC Data (XML) in the Request as shown below:

In this XML we have some fields which are unique and need to be changed every time we send the request else it will fail as duplicate record as below:

“There is an ongoing Customer Order with the same Customer Order ID”

We will bring uniqueness to the record in 2 ways:

1. Using the Data generated in a CSV file

2. Using a Beanshell sampler and change the Parameters in the xml

Method 1:

1. We will create a CSV file with the required data (may be Manual entry of the required format) and store it.

2. We have 3 fields which are required to be unique for creating an order.

3. The fields are as below defined in CSV Data Set Config:

4. Also, the fields in the xml are defined as below:

<core:value>${LOCATION_ID}</core:value>

<core:value>${CUSTOMER_ID}</core:value>

<core:value>${PHONE1}</core:value>

5. Once done if we run the test we can view in the Result Tree that the request passed as below :

Below is the Test Plan along with the Result.

Method 2:

In this method we will use a Beanshell Sampler to generate a random value for the required fields and replace them in the XML.

We will use timestamp and a unique postfix generated using a counter:

We have counter defined as below:

In Beanshell Sampler we had the below code:

The XML is same as used in Method 1.

Run the Thread and check in the View Results we have the below :

This is how we can run Webservices in Jmeter.

In the above methods, in case there is change in the XML we need to modify the SOAP/XML-RPC Request everytime.

CSS/jQuery Extractor usage

2015-04-23T11:23:00.001+05:30

CSS/jQuery Extractor usage:

JMeter offers CSS/jQuery Extractor that allows you to extract server responses using a CSS/jQuery-like syntax.

In this example, let us see how to use the CSS/jQuery Extractor component to extract information from server responses.

Steps:

Launch JMeter.
Create a Simple Testplan as below:

3. Add Thread Group, then HTTP Request

Add CSS/JQuery Expression Extractor by navigating to Request | Add | Post Processor | CSS/JQuery Extractor.
Fill in the values as follows:

The Response data for the HTTP Request have the below:

<h3>Must be heavy baby. This and that...</h3>

<p>Thoughts on Scala</p>

<p>Posted by tom</p>

</div>

<h3>Lorem ipsum dolor sit amet</h3>

<p>Another Post</p>

<p>Posted by jim</p>

</div>

And so on.

Using CSS/JQuery we will capture text with <h3> tag

6. Save and run the script.

Open Debug Sampler and check whether the expression matches the intended query. This is shown in the following screenshot:

Note: Compared to Regular Expression Extractor, CSS/jQuery Extractor is resource-intensive as it does a complete HTML parse of the document to perform its work. Prefer Regular Expression Extractor.

Regular Expression Extractor Example

2015-04-22T15:42:00.004+05:30

Regular Expression Extractor Example

Today, we will use the Regular Expression Extractor component in JMeter to extract server responses to make our test script dynamic in nature.

The script recorded below is for a site that uses Cross-Site Request Forger (CSRF) to prevent against malicious attacks that prey on user vulnerability.

A token is attached to each user's session that is then sent along with every request from that user.

Each user gets their own unique token, and therefore, using the same token for two users flags an error on the server and the request is denied.

We will use Regular Expression to extract the CSRF token and correctly sent the unique token for the rest of the requests for that user in the test script.

Steps:

Launch JMeter.
Create a Script as below:

2 HTTP Requests, 1 with GET and 1 with POST
POST Request with Body data as {"value":"hello"}
Debug Sampler
View Results Tree
HTTP Cookie Manager

Run the script.
When we run the script as above, and observer the View Results Tree the script will fail at Regular Expression_Post with below Response code

Body size in bytes: 1081

Sample Count: 1

Error Count: 1

Response code: 403

Response message: Forbidden

If we observer the request data, it has the below details.

POST data:

{"value":"hello"}

Cookie Data:

XSRF-TOKEN=8qxW-YJ3OwA782MfIRAgs6RH;

Note: This token is changing for each user.

We observer a Forbidden stack in the Response data
Now Let us add “Regular Expression Extractor” as below:

8. All the requests pass in the View Results Tree

9. If we compare the Debug Sampler requests, we observe addition of token variables

JMeterVariables:

JMeterThread.last_sample_ok=true

JMeterThread.pack=org.apache.jmeter.threads.SamplePackage@16cc34c

START.HMS=155212

START.MS=1429611732154

START.YMD=20150421

TESTSTART.MS=1429696159316

token=tTgfZSJsFjxVjom57uXflYcL

token_g=1

token_g0=XSRF-TOKEN=tTgfZSJsFjxVjom57uXflYcL;

token_g1=tTgfZSJsFjxVjom57uXflYcL

Recording Jmeter Scripts behind a proxy server

2015-04-17T15:53:00.002+05:30

Recording Jmeter Scripts behind a proxy server

In one of the blog we saw the steps of recording Jmeter scripts using a proxy server.

JMeter has its own in-built Proxy Server, the HTTP(S) Test Script Recorder. This is only used for recording HTTP or HTTPS browser sessions as explained in below link.

http://nonfunctionaltestingtools.blogspot.com/2013/11/recording-using-http-proxy-in-jmeter.html

The above steps will work properly if the internet connection is not behind a proxy and can be accessed directly.
If we are testing from behind a firewall/proxy server or if we the internet access is provided using proxy server then the above steps will fail and will not record any of the steps.
Steps to record in Jmeter if the internet is accessed via proxy:

1. Start Jmeter with the firewall/proxy server hostname and port number.

To do so, Open a command prompt in windows and run the jmeter.bat file from a command line with the following parameters:

-H [proxy server hostname or ip address]
-P [proxy server port]
-N [nonproxy hosts] (e.g. *.apache.org|localhost)
-u [username for proxy authentication - if required]
-a [password for proxy authentication - if required]

Example: jmeter -H comproxy.server -P 8080 -u username -a password -N localhost

You can also use --proxyHost, --proxyPort, --username, and --password as parameter names

2. In this exercise instead of recording under WorkBench, let us record the requests under TestPlan. Once the Jmeter is launched

Add Thread Group under Testplan by following the steps as

Right Click on Test Plan -> Add -> Threads (Users) -> Thread Group

3. Now Right Click on WorkBench -> Add -> Non-Test Elements -> HTTP(S) Test Script Recorder

4. Under Global Settings of HTTP(S) Test Script Recorder provide the port as 6500.

Note: Here we are setting proxy which is only used for recording HTTP or HTTPS browser sessions. This is not to be confused with the proxy settings described above, which is used when JMeter makes HTTP or HTTPS requests itself.

Change the Target Controller to “Test Plan -> Thread Group”

Also Select the Grouping as “Put each group in a new transaction controller”

5. Now we need to change the proxy setting of our machine to records using the proxy port 6500. To perform the steps:

Open IE - >Internet Options -> Connections -> Lan settings

Under Proxy Server, Enter Address as “localhost” and Port as “6500” and click OK

6. Now in Jmeter Click on “Start” under HTTP(S) Test Script Recorder. Once we click on start a message will be displayed as below:

In Jmeter/bin directory a certificate will be present.

7. Now go to IE and open the required webpage to record. For example, open www.google.com

8. If the certificate is successful and has now issue, the steps will be recorded as shown below:

Some times if recording for the first time using Jmeter proxy we will get an error for certificate as “There is a problem with this website's security certificate.”. In that case we need to import the certificate from step 6 to the Internet Options -> Content -> Certificates and Import the correct certificate.

Once recording of the required steps are completed, stop the HTTP(S) Test Script Recorder.

Also change the proxy settings to the original settings to access internet.

Steps to Analyze AWR Report in Oracle

2015-04-06T11:40:00.000+05:30

Steps to Analyze AWR Report in Oracle

AWR - Automatic workload repository is a collection of persistent system performance statistics owned by SYS. It resides in SYSAUX tablespace. Bydefault snapshot are generated once every 60 min and maintained for 7 days. Each snapshot has a unique ID know as "snap_id". Snapshot detail can be found in "dba_hist_snapshot" view.

If we have Database performance issue and not the Database machine, then AWR Report is the place to look at. AWR is not used for real-time performance monitoring like the v$ tables. It is used for historical analysis of performance. AWR complements, but doesnot replace real-time monitoring.

Once AWR Report is generated in Oracle, the next task is to analyze it. By going through the AWR Report we can easily solve issues like slow database, high wait events, slow query and many more issues. Even though the report is lengthy, Analyzing or Reading relevant part of AWR Report can help to troubleshoot issues in easy and fast manner.

In case if a particular query is not performing well, look at execution plan of the query, stats of underlying table etc. In this case AWR won't help much.

General Tips before getting an AWR Report.

1. Collect Multiple AWR Reports: It's always suggested to have two AWR Reports, one for good time (when database was performing well), second when performance is poor. This way we can easily compare good and bad report to find out the culprit.

2. Stick to Particular Time: Always take the report during the time when the Database is performing slow. We have to have a specific time like Database was slow today at 10Am and continued till 2Pm. Here, we can get a report for these four hours.

3. Split Large AWR Report into Smaller Reports: Instead of having one report for long time like one report for 4hrs. it's is better to have four reports each for one hour. This will help to isolate the problem.

Now, let us walkthrough the report. Since, AWR report is a huge report and area to look into AWR is also depends on problem to problem. Here, I am listing most common area for a Performance Engineer to look into which will give a clear picture of the issue.

Steps to Analyze AWR Report:

Note: The Report is obtained using OEM with Oracle Release 12.1.0.1.0

1. Database Details:

After getting an AWR Report check the report generated is for the problematic DB. The details are shown in Top part of the report.

In this part cross check for database and instance and and database version with the Database having performance issue. This report shows RAC = NO if it is not a RAC DB.

2. Host Configuration:

This will give you name, platform CUP, socket and RAM etc. Important thing to notice is that the configuration like CPU and Memory has not changed when the performance is degraded.

3. Snap Shot Detail:

This are the detail about snap shot taken, Snap start time and end time. Difference between them is as "Elapsed".

DB Time= session time spent in database.

DB Time= CPU Time + Non IDLE wait time.

In Systems with multiple concurrent active sessions, DB time can be larger than elapsed time. We can see that DB time is very large as compared to Elapse time, which is not a concern. Check if you have taken a report for the time having performance problem. If yes fine, otherwise take a report for performance problem time.

4. Load Profile:

Here are few important stats to look into. First is "DB CPU(s)" per second. Before that let's understand how DB CPU's work. Suppose you have 8 cores into the system. So, per wall clock second you have 8 seconds to work on CPU.

So, if "DB CPU(s)" per second in this report > cores in (Host Configuration (#2)) means env is CPU bound and either need more CPU's or need to further check is this happening all the time or just for a fraction of time.

In this case, machine has 8 cores and DB CPU(s) per second is 0.1. So, this is not a CPU bound case.

Next look at Parses and Hard parses. If the ratio of Hard parses to Parses is high, this means Database is performing more Hard parses. In that case we needs to look at parameters like cursor_sharing and application level for bind variables etc.

In the above we have no issue with parses.

Parse issues usually occur as a result of:

Bad Bind variables usage

Insufficient memory

Will also be co-indicated by low percentage of memory for multiple SQL execution.

5. Instance Efficiency Percentages:

Note: DB Tuning must never be driven by the Hit ratios. These only provide additional information for help to understand how the instance is operating.

Meanings of particular Hit Ratios:

a. Buffer Nowait%: Shows the % of times when data buffers were accessed directly without any wait time.

b. Buffer Hit Ratio : Measures how many times a required block was found in memory rather than having to execute an expensive read operation on disk to get the block.

c. Library Hit%: Shows the % of times when SQL statements and PL/SQL packages were found in the shared pool.

d. Execute to Parse %: Shows how often parsed SQL statements are reused without re-parsing.

e. Parse CPU to Parse Elapsed %: Gives the ratio of CPU time spent to parse SQL statements.

f. Redo NoWait %: Shows whether the redo log buffer has sufficient size.

g. In-memory Sort %: Shows the percentage of times when sorts are performed in memory instead of using temporary tablespaces.

h. Soft Parse % : Shows how often sessions issued a SQL statements that is already in the shared pool and how it can use an existing version of the statement.

i. Latch Hit %: Shows how often latches were acquired without having to wait.

j. % Non-Parse CPU : Shows the percentage of how much CPU resources were spent on the actual SQL execution.

In these statistics, you have to look at

Soft Parse % ~ 100% indicates that the SQL statements are actively re-used.

"% Non-Parse CPU". ~ 100% means most of the CPU resources are used into operations other than parsing, which is good for database health.

Parse CPU to parse Elapsed % : It is very low, it reveals that oracle waits for some resources during parsing of SQL statements. To be investigated further.

Rule of thumb: Always minimize the number of Hard parses. This reduction yields the benefits of minimizing CPU overhead spent performing costly parse work.

6. Top 10 Foreground Events by Total Wait Time:

This is another most important stats to consider while looking at AWR Report for any database performance related issue. This report is critical because it shows those database events that might constitute the bottleneck for the system. This has a list of top 10 foreground events arranged by Total Wait Time.

Here, first of all check for wait class if wait class is User I/O , System I/O, Others etc this could be fine but if wait class has value "Concurrency" then there could be some serious problem. Next to look at is Total Wait Time (sec) which show how many times DB was waiting in this class and then Wait Avg (ms). If Total Wait Time(sec) are high but Wait Avg(ms) is low then you can ignore this. If both are high or Wait Avg(ms) is high then this has to further investigate.

In the above screen shot, most of the resource are taken by Log file sync = 91.9% DB time and the wait class is “Commit”

In this report the event is "log file sync" which has high Waits, huge % DB time and large values in Total Wait Time (sec) and Wait Avg(ms) with wait class as commit. So, here you have to investigate further.

Note : Use highest Total Wait Time(sec) to guide investigation.

Next are Wait Classes by Total Wait Time, Host CPU, Instance CPU, IO Profile, Memory Statistics, Cache Sizes are self-explanatory.

Point to remember while checking these results :

Ø Watch for number of CPUs

Ø Pay attention to changes in Memory size

Ø An idle CPU can be a bad thing

Ø Always look at Wait IO verses CPU usage

Ø If the system is IO bound CPU will be idle!

7. Shared Pool Statistics:

In general, Memory usage % statistics should be ~70% after the DB has been running a long time. If its quite low, memory is being wasted. Here in our report we have Memory Usage % ~50% which is good.

In case if we have this to ~90% or above as shared pool consumed. This could indicate that the system experiences some overhead while aging out old shared memory structures like cursors, PL/SQL programs, and so on. This will place additional overhead on the CPU to perform reparsing aging-out. The size of the shared pool should be increased appropriately to eliminate such overhead.

The % SQL with executions >1 statistics indicate how many SQL statements are executed more than one time. This measures how well the applications are tuned and how well they make use of Bind variables.

8. Time Model Statistics:

This is a detailed explanations of system resource consumptions. Stats are order by Time (s) and % of DB Time.

Some times Sum of all % of DB time may be > 100%. why is this ?

Because this is cumulative time i.e. SQL execute elapsed time may show more DB time, which includes it sub parts like parse time elapsed, hard parse elapsed time etc. So, if you find Hard parse time elapsed is taking more %. So investigate further so on and so forth.

We have to look for stat which is taking abnormal % of DB time.

9. Operating System Statistics - Detail:

This is the information related to OS, what is the load status on System shown here.

This report shows, system is 97 to 98% idle at time of report taken, So, there is no resource crunch at system level. But if, you found very high busy, user or sys % and indeed this will led to low idle %. Investigate what is causing this.

Next, very crucial part of AWR report is SQL Statistics which has all sql query details executed during report time interval.

We will explore few of them, To understand, how to analyzed these reports. Let's start with

10. SQL Ordered by Elapsed Time:

As explained by name itself, this lists SQL queries ordered by Elapsed time into reported time interval.

In this report, look for query which has low executions and high Elapsed time per Exec (s) and this query could be a candidate for troubleshooting or optimizations.

Important point: some times executions may show 0, it doesn't mean query is not executing, this might be the case when query was still executing and you took AWR report. That's why query completion was not covered in Report.

11. SQL Ordered by CUP Time:

In this report, SQL queries are listed on the basis of CPU taken by the query i.e. queries causing high load on the system. The top few queries could be the candidate query for optimization.

From above stat, look for queries using highest CPU Times,

However, there are so many other stats in AWR Report which needs to be considered; here I have listed the most commonly used stats for any performance related information.

Capturing the required details of a machine before starting Performance tests

2015-04-01T18:11:00.000+05:30

We often check the machine details while before starting our performance tests. These details are very much required to know the type of H/W we are using for particular tests.

Examples:

Below is the example of Data Node details used as part of HBase cluster

Data Node:

a) 6 x Dell PowerEdge R720 Nodes

Each with

b) 2 x E5-2680 V2 2.8GHz 10-core, HT=ON

c) 192 GB RAM

d) 13 x PERC 900GB 15K 6Gbps SAS 2.5" SFF HS HDD , Total storage ~12 TB

e) 10Gb/s Full Duplex, Auto-Negotiation off

Explanation:

a) 6 is the number of Region Servers. Followed by Manufacturer and Product Name

Any of the below Commands can be used in Linux to get specific details:

1. To get Manufacturer and Product Name:

[root@illin2933 ~]# dmidecode | grep -A3 '^System Information'

System Information

Manufacturer: Dell Inc.

Product Name: PowerEdge R720

Version: Not Specified

Note: Above command requires sudo access

2. To get Model and vendor of the Device

$ cat /sys/class/block/sda/device/{model,vendor}

PERC H710P

DELL

3. To get device model

$ awk '{ print FILENAME, $0 }' /sys/class/block/sd[a-z]/device/model

/sys/class/block/sda/device/model PERC H710P

/sys/class/block/sdb/device/model PERC H710P

/sys/class/block/sdc/device/model PERC H710P

/sys/class/block/sdd/device/model PERC H710P

/sys/class/block/sde/device/model PERC H710P

/sys/class/block/sdf/device/model PERC H710P

4. To get type, size and model of the disks

$ lsblk -io KNAME,TYPE,SIZE,MODEL

KNAME TYPE SIZE MODEL

loop0 loop 3.6G

sdb disk 837.8G PERC H710P

dm-2 lvm 810G

sdc disk 837.8G PERC H710P

dm-3 lvm 810G

sdd disk 837.8G PERC H710P

dm-4 lvm 810G

sde disk 837.8G PERC H710P

dm-5 lvm 810G

sdf disk 837.8G PERC H710P

dm-6 lvm 810G

sdh disk 837.8G PERC H710P

b) This gives details of the CPU Info.

Details are obtained using:

$ cat /proc/cpuinfo

Example output:

processor : 39

vendor_id : GenuineIntel

cpu family : 6

model : 62

model name : Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz

stepping : 4

cpu MHz : 2800.063

cache size : 25600 KB

physical id : 1

siblings : 20

core id : 12

cpu cores : 10

apicid : 57

initial apicid : 57

fpu : yes

fpu_exception : yes

cpuid level : 13

wp : yes

flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon pebs bts rep_good xtopology nonstop_tsc aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 cx16 xtpr pdcm pcid dca sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm ida arat xsaveopt pln pts dts tpr_shadow vnmi flexpriority ept vpid fsgsbase smep erms

bogomips : 5598.78

clflush size : 64

cache_alignment : 64

address sizes : 46 bits physical, 48 bits virtual

power management:

We capture only : 2 x E5-2680 V2 2.8GHz 10-core, HT=ON

2 is Number of Physical CPUs. From above command it is obtained in physical id (0 and 1).

Followed by Model name and CPU cores.

Since we have CPU cores = 10 x 2 Physical CPU = 20 CPUs but processor shows 40 due to Hyper threading enabled. So HT = ON

More info can be found:

http://nonfunctionaltestingtools.blogspot.in/2011/06/how-to-find-number-of-physical-cpus-in.html

c) RAM on the machine

$ cat /proc/meminfo

MemTotal: 198179544 kB

MemFree: 53268644 kB

Buffers: 3398204 kB

Cached: 102307104 kB

SwapCached: 0 kB

Active: 44405388 kB

Inactive: 96615136 kB

Active(anon): 30908168 kB

We capture only : MemTotal ~ 19GB

d) Hard Disk details:

13 x PERC 900GB 15K 6Gbps SAS 2.5" SFF HS HDD , Total storage ~12 TB

13 is the number of disks used.

PERC (PowerEdge RAID Controller (PERC)) is the model with 900GB size. Which can be obtained from command in a)

From Dell website we can get details on the Interface support etc as below.

Model	Interface Support	PCI Support	SAS Connectors	Cache Memory Size	Write Back Cache	RAID Levels	Max Drive Support	RAID Support
PERC H710P Adapter	6Gb/s SAS	PCI-Express 2.0	2x4 Internal	1GB NV	Flash Backed Cache	0,1,5,6,10,50,60	32	Hardware RAID

RAID Hardware Info can be obtained as below:

# lspci -vv | grep -i raid

02:00.0 RAID bus controller: LSI Logic / Symbios Logic MegaRAID SAS 2208 [Thunderbolt] (rev 05)

Kernel driver in use: megaraid_sas

Kernel modules: megaraid_sas

e) Network Specifications: 10Gb/s Full Duplex, Auto-Negotiation off

Command used to capture the above:

# dmesg |grep em1

udev: renamed network interface eth0 to em1

bnx2x 0000:01:00.0: em1: using MSI-X IRQs: sp 124 fp[0] 126 ... fp[7] 133

bnx2x 0000:01:00.0: em1: Warning: Unqualified SFP+ module detected, Port 0 from CISCO-MOLEX part number 74752-9521

bnx2x 0000:01:00.0: em1: NIC Link is Up, 10000 Mbps full duplex, Flow control: ON - receive & transmit

# ethtool em1

Settings for em1:

Supported ports: [ FIBRE ]

Supported link modes: 1000baseT/Full

10000baseT/Full

Supported pause frame use: Symmetric Receive-only

Supports auto-negotiation: No

Advertised link modes: 10000baseT/Full

Advertised pause frame use: No

Advertised auto-negotiation: No

Speed: 10000Mb/s

Duplex: Full

Port: Direct Attach Copper

PHYAD: 1

Transceiver: internal

Auto-negotiation: off

Supports Wake-on: g

Wake-on: d

Current message level: 0x00000000 (0)

Link detected: yes

What Is Capacity Planning?

2015-03-25T14:50:00.003+05:30

What Is Capacity Planning?

Capacity planning is the process of determining what type of hardware and software resources are required for running an application with a given user load at a satisfactory level of service. It is a continuous and iterative process that ensures that the required computing resources (primarily, hardware) for an application are available at the right time.

Capacity planning determines what your system needs (and when it needs it) to maintain performance in both steady-state and peak usage periods.

Capacity Planning involves designing your solution and testing the configuration, as well as identifying business expectations, periodic fluctuations in demand, and application constraints. You need to plan carefully, test methodically, and incorporate design principles that focus on performance. Before deploying any application into a production environment, the application should be put through a rigorous performance testing cycle.

While planning for capacity, always consider future growth requirements. It is important to determine future requirements, well in advance, so that necessary action can be taken to plan for, procure, and install the required resources. Besides ensuring that adequate resources are available for meeting the performance and scalability requirements, capacity planning can save considerable money and resources for the organization.

Purpose of Capacity

Planning Capacity planning is necessary for the following purposes:

1. To achieve predictable and consistent performance

The load on a system may not always be uniform; it may at times low, high, to very high than normal anticipated Load. Capacity planning helps you provide users a satisfactory level of service at varying server loads. If capacity is not planned, and if adequate resources are not available, users may experience significant variation in performance as the load varies. At very high loads, the system may run so slow that users cannot even use the system.

2. To determine scalability characteristics

Capacity planning helps in determining the scalability characteristics of the application. If the available hardware resources are not adequate for the current load or if the load is expected to increase in future, we can estimate the additional hardware resources required to maintain or improve performance.

3. To identify current capacity

Capacity planning helps in identifying limitations of the existing hardware.

4. To estimate the additional hardware required to support increased demand

Capacity planning helps in estimating the additional hardware resources necessary for the increased load due to factors such as business expansion and changes in marketing strategy.

The following data must be recorded while running the tests:

Application behavior

– Concurrent user load

– Response time

– Throughput

Resource utilization

– CPU utilization

– Memory footprint

– Network utilization

– I/O utilization

Important Tests to run as part of Capacity Planning:

1. Scalability Tests

Vertical Scalability (Scaling up)

Scaling the system by providing additional hardware resources on the

existing machines. For e.g. increasing the number of CPUs and/or memory on a

given server.

Horizontal Scalability (Scaling out)

Scalinge the system by distributing the load on more number of machines.

Usually this is achieved through the use of a load balancer that routes the traffic across multiple application clones running on separate physical servers.

2. Stress Tests

3. Load Tests

/bin/bash^M: bad interpreter: No such file or directory

2015-02-24T18:35:00.003+05:30

While running some sh scripts i faced the below issue.

[biadmin@illinxxxx scripts]$ ./nftp_vals.sh

./nftp_vals.sh: ./nftcontroller.sh: /bin/bash^M: bad interpreter: No such file or directory

./nftp_vals.sh: ./throughput_and_latency.sh: /bin/bash^M: bad interpreter: No such file or directory

./nftp_vals.sh: ./detailedreport.sh: /bin/bash^M: bad interpreter: No such file or directory

./nftp_vals.sh: ./nftreader.sh: /bin/bash^M: bad interpreter: No such file or directory

Cause:

This issue is caused when creating scripts in Windows env and then porting over to run on a unix environment.

Unix uses different line feeds and carriage returns so can't read the file you created on Windows. Hence it is seeing ^M as an illegal character.

Resolution:

Just run dos2unix -k -o <filename> and the issue will be fixed.

E.g.:

[biadmin@illinxxxx scripts]$ dos2unix -k -o nftcontroller.sh

dos2unix: converting file nftcontroller.sh to UNIX format ...

[biadmin@illinxxxx scripts]$

By using the below command we can convert all the files within a directory and sub-directory in one shot!

find . -type f -exec dos2unix {} {} \;

Jmeter : Adding Perfmon Metrics to Jmeter

2015-01-29T19:01:00.000+05:30

To add Perform Plugins into Jmeter we need to copy "JMeterPlugins-Standard.jar" under lib/ext directory. This brings some more features of Perfmon as below:

More details about the plugin can be found @ http://jmeter-plugins.org/wiki/PerfMonAgent/

Using this we can capture the Server side metrics like CPU, Memory,Disk I/O, Network I/O ..etc.

To collect all the Metrics using PerfMon we need to add On TestPlan -> Add -> Listener -> "jp@gc - PerfMon Metrics Collector".

Specific the Host/IP, Port, Metric to Collect and filename to store the results as shown below:

We can also add other Listeners also.
Some important ones to add are as below:

JMeter : Error while loading TestPlan - "Unexpected Error -see log"

2015-01-29T16:00:00.001+05:30

I tried to open a test plan (.jmx file) in JMeter which was created by one of my colleague. The error said “Unexpected error – see log for details”.

2015/01/29 15:30:30 INFO - jmeter.save.SaveService: All converter versions present and correct

2015/01/29 15:30:30 ERROR - jmeter.protocol.java.config.gui.JavaConfigGui: Error setting class:'com.nft.sampler. AdministratorSampler' in JavaCustomerAdministrator, check for a missing jar in your jmeter 'search_paths' and 'plugin_dependency_paths' properties

2015/01/29 15:30:30 ERROR - jmeter.protocol.java.config.gui.JavaConfigGui: Error setting class:'com.nft.sampler. CustomerSampler' in JavaSampler Customer, check for a missing jar in your jmeter 'search_paths' and 'plugin_dependency_paths' properties

2015/01/29 15:30:30 ERROR - jmeter.protocol.java.config.gui.JavaConfigGui: Error setting class:'com.nft.sampler. InvolvementSampler' in JavaSampler Involvement, check for a missing jar in your jmeter 'search_paths' and 'plugin_dependency_paths' properties

2015/01/29 15:30:30 ERROR - jmeter.gui.GuiPackage: Could not get GUI for kg.apc.jmeter.vizualizers.CorrectedResultCollector@1eda8f2 java.lang.ClassNotFoundException: kg.apc.jmeter.vizualizers.ResponseTimesPercentilesGui

at java.net.URLClassLoader$1.run(Unknown Source)

at java.security.AccessController.doPrivileged(Native Method)

at java.net.URLClassLoader.findClass(Unknown Source)

at java.lang.ClassLoader.loadClass(Unknown Source)

at java.lang.Class.forName0(Native Method)

Solution:

If the error log is observed we see 4 different errors.

First 3 errors relates to the Samplers missing.

The issue is resolved after copying the required sampler jar under \lib\ext directory.

As the error suggests “kg.apc.jmeter.vizualizers.ResponseTimesPercentilesGui”, it was looking for ResponseTimesPercentilesGui in vizualizers.

The issue got resolved after “JMeterPlugins-Extras.jar” under “<Jmeter PATH>\lib\ext” directory.

This fixed the problem. I was able to load my test plan successfully.

JMeter :Error while loading TestPlan - See Log File

2015-01-29T15:57:00.001+05:30

Today, I tried to open a test plan (.jmx file) in JMeter which was created by one of my colleague. The error said “Empty TestPlan – see log file”.

The following error is present in Jmeter.log:

2015/01/29 15:20:50 INFO - jmeter.gui.action.Load: Loading file: C:\Users\Desktop\jmeter\consolidatedayStability.jmx

2015/01/29 15:20:50 INFO - jmeter.services.FileServer: Set new base='C:\Users\Desktop\jmeter'

2015/01/29 15:20:50 ERROR - jmeter.save.SaveService: Conversion error com.thoughtworks.xstream.converters.ConversionException: kg.apc.jmeter.vizualizers.CorrectedResultCollector : kg.apc.jmeter.vizualizers.CorrectedResultCollector

---- Debugging information ----

message : kg.apc.jmeter.vizualizers.CorrectedResultCollector

cause-exception : com.thoughtworks.xstream.mapper.CannotResolveClassException

cause-message : kg.apc.jmeter.vizualizers.CorrectedResultCollector

class : org.apache.jorphan.collections.ListedHashTree

required-type : org.apache.jorphan.collections.ListedHashTree

converter-type : org.apache.jmeter.save.converters.HashTreeConverter

path : /jmeterTestPlan/hashTree/hashTree/hashTree/kg.apc.jmeter.vizualizers.CorrectedResultCollector

line number : 212

------------------------------- : kg.apc.jmeter.vizualizers.CorrectedResultCollector : kg.apc.jmeter.vizualizers.CorrectedResultCollector

---- Debugging information ----

message : kg.apc.jmeter.vizualizers.CorrectedResultCollector

cause-exception : com.thoughtworks.xstream.mapper.CannotResolveClassException

cause-message : kg.apc.jmeter.vizualizers.CorrectedResultCollector

class : org.apache.jorphan.collections.ListedHashTree

required-type : org.apache.jorphan.collections.ListedHashTree

converter-type : org.apache.jmeter.save.converters.HashTreeConverter

path : /jmeterTestPlan/hashTree/hashTree/hashTree/kg.apc.jmeter.vizualizers.CorrectedResultCollector

line number : 212

-------------------------------

message : kg.apc.jmeter.vizualizers.CorrectedResultCollector : kg.apc.jmeter.vizualizers.CorrectedResultCollector

Solution:

As the error suggests “kg.apc.jmeter.vizualizers.CorrectedResultCollector”, it was looking for CorrectedResultCollector in vizualizers.

The issue got resolved after “JMeterPlugins-Standard.jar” under “<Jmeter PATH>\lib\ext” directory.

This fixed the problem. I was able to load my test plan successfully.