Performance blog

New Blog

2023-05-13T09:15:00.006-07:00

I have published more content on my new blog. You can access it through the link provided below

https://vamsitokala.blogspot.com/

@2011, copyright Vamsidhar Tokala

Detecting LDAP Performance Issues

2016-05-26T22:55:00.000-07:00

Detecting LDAP Performance Issues

We had detected significant degrade in response times recently related to LDAP during the load tests and we were not sure the reasons for the slowness.

I took the following approach to debug the issue

Captured the LDAP traffic in the server using TCP Dump( Linux)
Import the dump in Wireshark
Modify Display Filter

Tcp.dstport == port no
and decoded the traffic as shown below
1. Value is port used to communicate the LDAP Server
2. LDAP is the communication protocal in Wireshark

5 TCP traffic is more readable and I was able to detect the issue with LDAP search against our application and administrators groups

@2016, copyright Vamsidhar Tokala

Interesting Work - Part2

2015-12-09T01:50:00.001-08:00

System Setup

Ø System was configured as below for performance benchmark

o No of Claims Engine Servers configured – 20

o No of Instances of Adjudication service running per Claims Engine Server – 4

o No of Threads per Adjudication Service – 5

Test Execution

Soon after being engaged for the performance validation effort, we engaged in the following Activities

11) A new environment was setup for the Proof of Concept.

22) Developed automated scripts to Load members, providers and claims

33) Loaded data incrementally to reach the expected volumes via automated SQL scripts

o 24 Million Members,

o 1 Million Providers,

o 60 million Claims

44) Initially Tested adjudication with only professional claims to validate the scalability and performance. Distributed the Adjudication service across multiple servers.

Performance was slow even with 50,000 Claims

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)
1000	Professional	4	1	5	1.5
18000	Professional	4	1	5	40 min
50,000	Professional	4	10	5	2 hrs(stopped)
50,000	Professional	4	3	5	2 hrs 20min

Analysis

a. Observed several queries from portal and other jobs blocking the adjudication service. The following were the top 5 worst queries at the time of the test.

Name	max_logical_reads	max_elapsed_time
udp_Mem_Enrollment	146322516	805341120
plx_cl_dataset	1058518	29350681
claim_result_code	14038	2145120
claim_run__code	14038	15784905
plx_get_dataset	3326	2042115

b. These queries are originating from Portal servers. Decision taken to shut down all the server except Claims Engine and SQL servers

c. Response time Improved from 2 hr to 34 min for 50K after the shutdown

No of Claims	Claim Type	No of Servers	No of Adjudication services/Server	No of Threads/ service	Processing Time (in minutes)
50,000	Professional	4	3	5	2 hrs 20min
50,000	Professional	4	3	5	34 min

5) Tests with 200K professional claims

Ran series of performance tests with 200K professional claims. We hit 2 hrs mark with the test

· CPU utilization in DB was around 60-80%

· Memory around 92%

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)	Comments
200,000	Professional	4	10	5	2 hr 30 min	With 10 claims engine servers
200,000	Professional	4	6	5	2 hr 05 min	Reduced no of servers to avoid DB contention

Analysis:

a. Reducing the no of Claims engine servers from 10 to 6 improved the processing time by 20%. We found that the database becoming a bottleneck on increase in the no of servers

66) To test and tune some of the config changes faster, Ran series of tests with reduced volumes.

Improved the performance incrementally via snapshot isolation, adding appropriate indexes, partitioning etc.

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)	Comments
50,000	Professional	4	3	5	35 min	Turned off ALLOW_PAGE_LOCKS and set LOCK_ESCALATION=DISABLE on adjudication_key Table - Reverted back the changes
50,000	Professional	4	3	5	33 min	tested Dedicated Queue per service in each server Reverted back the changes
50,000	Professional	4	3	5	33 min	Modified partition for adjudication_key table based on adjudication object id
50,000	Professional	4	3	5	39 min	Created index for procedure code table which improved Index seeks, key lookups etc.
50,000	Professional	4	3	5	32 min	Snapshot isolation is enabled in DB

7. Observed one of Stored procedures was slow during the test

a. Observed plx_counter stored proc take more time in the process of adjudication

SP Name	TotalLogicalReads	AvgLogicalReads	execution_count	Calls/Second	total_elapsed_time	avg_elapsed_time
plx_counter	5127899	26	190674	3	2746844057	14405

b. plx_counter is updated with a sequence in DB and elapsed time improved from 14405 micro sec to 118 micro secs

SP Name	TotalLogicalReads	AvgLogicalReads	execution_count	Calls/Second	total_elapsed_time	avg_elapsed_time
plx_counter	12	0	7145	27	849034	118

c. The below tests executed after the stored proc is updated

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)
50000	Professional	4	3	5	31 min
200000	Professional	4	6	5	2 hrs

87) No of Virtual CPU increased from 8 to 16 in Database server and memory increased to 32 GB

Not much improvement observed with the increase of logical CPU’s and memory. Network edge is configured to low in terms of bandwidth. It was modified to high now and results were same, even after modifying to high

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)	Comments
200000	Professional	4	6	5	2hrs 30 min +	With 16 core processer and 32 GB memory,
200000	Professional	4	6	5	2 hrs 35 min	With 16 core processer and 32 GB memory Changing the network edge to high

98) Evaluated the below network configurations. However Results didn’t show any improvement in performance

· Disable TCP Chimney.

· Disable all offloading in vmxnet3 at OS level

· Disable all offloading at NIC level

19) VMWare Restrictions

a. Memory

- Though we see 32 GB of RAM in the DB box, there was an restriction in VMware to use only 16 GB (16 GB was driver locked)

- Worked with VMware to reclaim and use all the 32 GB allocated

- DB server memory utilization was not beyond 80% after the reclaim

b. CPU

- Same as memory, we had reclaimed all the 16 core processer for usage

- CPU utilization was not beyond 25%.

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)
200000	Professional	4	8	5	1 hr 6 min
200000	Mix	4	8	5	1 hr 16 min

110. Hyper thread ratio not configured correctly IN VMWare

Hyper thread ratio is changed to 16. Total Logical CPU is 32

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)
200000	Mix	4	10	5	55 min
200000	Mix	4	10	5	59 min
200000	Mix	4	10	5	62 min
200000	Mix	4	15	5	45 min

111). Increased Claims History from 60 Million claims to 780 Million claims. Out of 780 Million claims, 9 Million were completed and in approved status and rest were in Open status.

No of Adjudicated Claims	Avg No of Claims per Member	Processing Time
9 Million	1	48 min
9 Million	15	70 min

112) Observed only 20 out of 32 CPU cores utilized during the test due to SQL Server license limitations. Reinstalled the SQL server with upgraded license that uses all cores.

Performance improved from 66 min to 55 min

No of Claims	Claim Type	No of Adjudication services/Box	No of Servers	No of Threads/service	Processing Time(in minutes)
200000	Mix	4	20	5	55 min

Database changes to Improve Performance

There were several Configuration and Schema changes done to the database to enhance performance.

TempDB

Ø There was only one data file for TempDB for the entire server. Best practices state that there should be as many data files for TempDB as processors. At the time we changed the configuration on this, the number of processors was 8. It is now 16. We might want to consider adding more data files.

Ø The default sizes of the TempDB data files was too small. The default setting of TempDB upon installation is 8 MB. When the server reboots, the TempDB data files will always resort back to its original size. The files were expanding a lot from regular usage so the default was changed to 2 GB with 1 GB used as the setting for the log file.

Config Changes

Ø Max Degree of Parallelism: This was set to 40.

Ø Network Packet Size: This was set to 10240.

Ø Query Wait: This was set to 15.

Ø Minimum Server Memory: This was set to 16GB.

Ø Maximum Server Memory: This was set to 24GB.

Ø Snapshot isolation enabled in DB

Partitioning:

· 4 tables related to 700 million claims were partitioned in the database.

· They were partitioned by their clustered primary keys.

· 4 new file groups were created to separate the data from the rest of the database.

Fill Factor:

· The default Fill Factor for indexes was changed to 80.

Recovery Mode:

· This was changed to Simple.

@2015, copyright Vamsidhar Tokala

Interesting work

2015-10-28T19:42:00.000-07:00

I am doing some exiting stuff on performance testing and engineering for a product which processes claims and business logic accordingly to the rules defined in it. I cannot provide more details of the product considering sensitive nature.

This product is very complex system with a multi-tier architecture containing several COTS products integrated with it. One of our prospective customers who requested to get claims layer (one of the sub systems) to processes 200,000 claims in 1 hour with a Claim History of 780 Million Claims which is 10 times more than the volumes we envisaged for the product.

Previous benchmark for this subsystem was 9000 claims in 1 hour with empty Database history.

First Things First

We needed to first determine was this volume feasible? These types of volumes have traditionally been executed on mainframes, could they be transitioned to our hardware and software? We started to investigate our current test results and see if there were any indicators that we had hit our limits with our application. What we discovered was promising, we didn’t see servers being overexerted or the application bottlenecking. We also found that our current results indicated, that with some scaling, we would be able to hit volumes that would allow us to process 200,000 transactions.

With this information in hand, we went back to our leadership team and started discussing what the scope of the effort would be. As we discussed, we found discovered was a time constraint involved of only about 6 weeks, which led us to narrow our focus. We decided that to best meet the goals we would work in a “quiet environment”, focusing only on claims processing.

We also needed to add some additional parameters to our setup. We needed to load 24,000,000 users, 1,000,000 supporting data, and 780,000,000 claims which all had to be loaded into a new environment before we could begin testing. This added its own set of challenges and forced us to “think outside the box” and create unique ways to load data in a quick manner. We began planning for how we could load data incrementally and still be able to test. We used a combination of SQL scripts to directly insert data to the DB and existing processes within application to load data. We spread the execution across the multiple server instances we had and varied the execution to not conflict with test execution.

With the requirements in place as well as a plan to load data; we would try to answer the main question, “Can we scale out our claims engine to process 200,000 claims in an hour?” Our plan to reach this goal was to add additional processing servers; based on our current metrics, we would need about 20. This seems like a straightforward and simple approach, however we didn’t want to just add 20 servers; this wouldn’t help us prove that servers is able to scale over time, so we decided to take a more incremental approach. Our approach was to start with four additional servers and then add more as they became saturated.

We had our plan and our goals, now all we needed to do was test!

T’s & C’s of Testing

In order to create valid tests, we needed 200,000 users that we could use to process claims and we needed them to be unique to prevent our duplicate rules from flagging the claim and preventing it from being processed. We also needed to be able to test what various levels of claims history a user might have which could impact the processing speed. For example, does having no other claims in the system make the processed faster than having eight claims in history?

We created new claims in order to ensure that our rulesets were executed against the claims and that the testing was valid. We wanted to avoid negative testing scenarios, due to the time constraint, and focus on the positive scenarios. We also bypassed systems and added the claims directly to our queues to isolate our testing from external factors. We made this a repeatable process so that we could always test with clean data. The data was composed of three types of claims, professional, institutional, and pharmacy. We did this to properly replicate not only the volumes of claims, but the mix as well, that we would expect to see in a Production setting.

Once we had our test data prepared we moved on to formalizing our hardware setup and monitoring. We setup Dynatrace in order to monitor performance in the environments, along with utilizing Windows Profiler (winDbg), and SQL Profiler to gather metrics. We used these metrics to determine where we needed to address potential bottle necks, or where our setup needed to be reconfigured. The reconfiguring could be adding new memory or CPUS, adding more hard drive space, or even adding an entire server. We setup four processing servers and one DB server and prepared to run our first cycle of testing.

Claim processing layer Architecture

Our Services are hosted in NServiceBus in Web Services Layer (Interface between the Client(other interfaces) and core NServiceBus) and Business Services Layer (Service Business Logic).

Coming up next time: Test Execution and learning's

@2015, copyright Vamsidhar Tokala

FTP Performance testing

2014-05-02T04:55:00.000-07:00

The below C# code was developed to place EDI X12(HIPPA) files directly into the FTP folder for batch testing.

  The below script will also help

·         To Test FTP server by placing larger number of files into FTP server as expected in production

·         To minimize the randomness in the testing process and ensures repeatability

using System;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Net;

using System.Text;

using System.Drawing;

using System.IO;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Generic;

namespace FTPScript

{

    [TestClass]

    public class UnitTest1

    {



        [TestMethod]

        public void main()

      {

            string sDir="C:\\270";// Directory containing Test data files

            List<FileInfo> files = new List<FileInfo>();

            try {

                           foreach (string f in Directory.GetFiles(sDir)) {

                                  files.Add(new FileInfo(f));

                           }

            }

            catch (System.Exception excpt)

            {

                throw excpt;

            }

           /* List files = new List();

            files.Add(new FileInfo("C:\\270\\270.txt"));

            files.Add(new FileInfo("C:\\270\\270_DOB.DAT"));*/



            Parallel.ForEach(files, objFile =>

                                                                      {

                                                                          UploadFile(objFile);

                                                                      });

        }

        static bool UploadFile(FileInfo fileInfo)

            {

                FtpWebRequest request = null;

                try

                {

                    string ftpPath = ftp://XXX.XX.XX.XX/CC + fileInfo.Name;

                    request = (FtpWebRequest)WebRequest.Create(ftpPath);

                    request.Credentials = new NetworkCredential("XXXX\\XXX", "XXXXX"); // username , password

                    request.Method = WebRequestMethods.Ftp.UploadFile;

                    request.KeepAlive = false;

                    request.Timeout = 60000; // 1 minute time out

                    request.ServicePoint.ConnectionLimit = 15; // Connection limit 15 with the ftp., By default 2, -1 means infinite.

                    byte[] buffer = new byte[1024];

                    using (FileStream fs = new FileStream(fileInfo.FullName, FileMode.Open))

                    {

                        int dataLength = (int)fs.Length;

                        int bytesRead = 0;

                        int bytesDownloaded = 0;

                        using (Stream requestStream = request.GetRequestStream())

                        {

                            while (bytesRead < dataLength)

                            {

                                bytesDownloaded = fs.Read(buffer, 0, buffer.Length);

                                bytesRead = bytesRead + bytesDownloaded;

                                requestStream.Write(buffer, 0, bytesDownloaded);

                            }

                            requestStream.Close();

                        }

                    }

                    return true;

                }

                catch (Exception ex)

                {

                    throw ex;

                }

                finally

                {

                    request = null;

                }

                //return false;

            }// UploadFile

    }

}

@2011, copyright Vamsidhar Tokala

Synthetic monitoring

2013-06-18T10:02:00.001-07:00

I have recently published a document on synthetic monitoring. Abstract is given below

Abstract:

Many large organizations have started implementing web content management (WCM) platform to maximize their online presence and improve operational efficiency across web based initiatives. These platforms have to support a large number of users accessing the application from multiple countries/regions with optimum performance. Platforms also have to achieve high availability for the published websites and its content management platform.

IT operations team responsible for managing the digital platform has to ensure the performance and availability requirements are met and take corrective actions if required. It must have the process which can alert the team with a performance issue as and when it is detected, understand the severity and complexity of the issue and diagnosing the issue with the available information.

Synthetic monitoring can help IT operations for managing and optimizing web application availability, performance of applications from the end-user perspective. This paper highlights the approach used to implement synthetic monitoring for a WCM platform and lessons learned from its implementation.

https://docs.google.com/file/d/0BzOftuUbGkRvOUYxWU1iMmVGMmM/edit?usp=sharing

@2013, copyright Vamsidhar Tokala

Akamai Configuration

2012-09-14T09:34:00.000-07:00

I have done my first akamai CDN implimentation for CQ5 publish in my project. I have listed the prerequisites and the configuration I have implimented.

DNS Setup

DNS Domain has to be configured to set-up with Akamai and for the domain to work its need to be registered and mapped to below name servers. This will allow Domain configurations to work

Following URL is configured for Akamai testing:

http://XXX-performance-testing.utils-XXX.com:4503/

Note: There is another workaround i.e. to register a temp domain via http://dnsdynamic.org
We can register a doming e.g. XXX-performance-testing.dnsdynamic.com and map it to IP: XXX.XXX.XXX.XXX

Akamai Configuration

Akamai is configured in the following fashion for optimal performance

ORIGIN SERVER CONFIGURATION

DIGITAL PROPERTIES CONFIGURATION SUMMARY

Default Configuration

(All Digital Properties) Origin: origin-nexus-performance-testing.utils-XXX.com

CP Code: Site Accelarator2 (125924)

Forward HOST header: Digital Property

Cache Key: Origin Server (origin-nexus-performance-testing.utils-XXX.com)

Compression: Yes

CACHE KEY: IGNORE CASE

OPTION VALUE

Ignore case in the cache key: Enabled

LAST MILE ACCELERATION

OPTION VALUE

Apply to content with Content-type: text/html*, application/x-javascript*, text/css*, image/png image/jpeg image/gif

Disable for Old Browsers: Yes

HTTP POST

OPTION VALUE

HTTP POST Requests: Enabled

Allow POST Without Content Length: Disabled

ORIGIN DNS OPTIMIZATION

OPTION VALUE

DNS Refresh: Enabled

DNS Refresh Timeout: 2 hours

TIME TO LIVE RULES

# MATCH CRITERIA ACTION

Default Rule TTL: 1 day

Default Error Response Rule 10 seconds

Default Cache Redirect Response Rule Cache Redirect Responses

1 Host: nexus-performance-testing.utils-XXX.com

File Extension: aif aiff au avi bin bmp cab carb cct cdf class css

dcr doc dtd exe flv gcf gff gif grv hdml hqx ico ini

jpeg jpg js mov mp3 nc pct pdf png ppc pws swa swf

txt vbs w32 wav wbmp wml wmlc wmls wmlsc xsd zip

TTL: 1 day

REPORTING

OPTION VALUE

HTTP Headers to Include in Logs: User-Agent

Cookie Values: - None -

SUREROUTE / TIERED DISTRIBUTION OPTIONS

OPTION VALUE

Tiered Distribution: Enabled

Tiered Distribution Map Name: ch2.akamai.net

SureRoute: On

SureRoute Test Object URI: /akamai/sureroute-test-object.html

Race Statistic TTL: 86400 seconds

Force Test Race Protocol to HTTPS: No

SITE ACCELERATOR

OPTION VALUE

Site Accelerator Enabled

GENERATE REDIRECT RULES

# MATCH CRITERIA GENERATE REDIRECT

1 Path: /index.html (Ignore Case On)

Redirect Name: Redirect_geometrixx

Redirect Option: Relative - Change URI

Response Code: 301 - Permanent Redirect

URL: /content/geometrixx/en.html

BROWSER CACHE CONTROL HEADERS

# MATCH CRITERIA CACHE CONTROL HEADERS

Default Rule Pass through the origin's Cache-Control

headers to the browser.

@2011, copyright Vamsidhar Tokala

Performance testing IPAD/Mobile applicatins

2012-03-07T23:19:00.000-08:00

Recently customers are requesting for performance testing IPAD/Mobile applications and I came across such a requirement recently. The challenge is to simulate the traffic and the typical approach to capture traffic using tools like LoadRunner may not work in this case due to the reasons below.

·         Tools like LoadRunner can’t be installed in IPAD/smart phones to record the flow and capture the communication.

·         Network capturing tools like Wireshark and Fiddler can’t be installed in IPAD.
The approach is to route the traffic from IPAD to a hub/router and capturing the communication using network monitoring tools like wireshark.

1)      Hub takes packets sent from one port and transmits (repeats) them to every other port on the device. For example, if a computer on port 1 of a 4-port hub needs to send data to a computer on port 2, the hub sends those packets to ports 1, 2, 3, and 4. When computer sends data, all computers connected to the hub receive it. Connect a computer to the hub which has Wireshark or fiddler installed to capture the communication.

2)      Second approach is to connect to a router and allow traffic to go through the proxy.
The below link has the approach followed by my team to capture communication using wireless router and fiddler

https://docs.google.com/document/d/1yh2Yi8MBNl0X4ClTZxYAl0iXEOQs8ZeZcJ1Kd4Cldq4/edit#

Finally download the BPC toolkit available in my blog to convert fiddler output to LoadRunner script.

Note: HP developed some Mobile apps protocol to test Mobile applications which takes Wireshark network trace as an input to create a script. Purchasing license for this protocol is not required if the above approach is followed

@2011, copyright Vamsidhar Tokala

Identifying Memory leaks in .Net using winDBG

2012-02-01T00:53:00.000-08:00

Identifying Memory Leaks due to object references in Finalize queue

Load the SOS debugger extension for a CLR 4.0 application

.loadby sos clr

1) Identify the objects in finalizeQueue which survived Garbage collection

!fq

SyncBlocks to be cleaned up: 0

MTA Interfaces to be released: 0

STA Interfaces to be released: 0

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

generation 0 has 1 finalizable objects (000000008ba63058->000000008ba63060)

generation 1 has 15 finalizable objects (000000008ba62fe0->000000008ba63058)

generation 2 has 14884 finalizable objects (000000008ba45ec0->000000008ba62fe0)

Ready for finalization 0 objects (000000008ba63060->000000008ba63060)

…

000007ff01d58610 2 1024 System.Data.DataTable

000007ff0164e298 4 1120 System.Diagnostics.Process

000007ff01d82738 8 1728 System.Data.DataColumn

000007ff017235a0 16 1920 System.Threading.OverlappedData

000007ff001f1780 28 2464 System.Threading.Thread

000007ff006764b8 52 3744 System.Reflection.Emit.DynamicResolver

000007ff0026fba8 66 4224 System.Threading.ReaderWriterLock

000007ff01e7bb00 314 10048 System.Data.SqlClient.SNIPacket

000007ff01e717e0 546 21840 System.Data.SqlClient.SNIHandle

000007ff01e49f30 314 32656 System.Data.SqlClient.SqlConnection

000007ff02933bf0 302 45904 System.Data.SqlClient.SqlDataAdapter

000007ff0166d240 398 70048 System.Diagnostics.PerformanceCounter

000007ff01e0d0e8 1510 338240 System.Data.SqlClient.SqlCommand

000007ff0057d8f8 11209 358688 System.WeakReference

2) You can also print the details of the finalizable objects for Gen2 using the above details

dd 000000008ba45ec0 000000008ba62fe0

3) Identify the suspected object having leaks

!dumpheap -type System.Data.SqlClient.SqlCommand

Address MT Size

0000000010c43f40 000007ff01e0d0e8 224

0000000010c44020 000007ff01e0d0e8 224

0000000010c44198 000007ff01e0d0e8 224

0000000010c44278 000007ff01e0d0e8 224

0000000010c444e8 000007ff01e0d0e8 224

4) Identify the GC roots for the objects. It contains the call stack

!gcroot 0000000010c43f40

Scan Thread 15 OSTHread 1bc0

Scan Thread 16 OSTHread 1d74

Scan Thread 19 OSTHread 3200

Scan Thread 17 OSTHread 21f0

Scan Thread 18 OSTHread 3564

Scan Thread 20 OSTHread 322c

Scan Thread 21 OSTHread 2b80

Scan Thread 28 OSTHread 2e5c

Scan Thread 29 OSTHread 35d0

Scan Thread 30 OSTHread 3bc

Scan Thread 31 OSTHread 2770

Scan Thread 33 OSTHread 19b4

Scan Thread 34 OSTHread 534

Scan Thread 35 OSTHread 3280

Scan Thread 36 OSTHread 1908

Scan Thread 37 OSTHread 344c

Scan Thread 38 OSTHread 13d4

Scan Thread 39 OSTHread 21d4

Scan Thread 40 OSTHread 31a4

DOMAIN(0000000001AB88B0):HANDLE(Pinned):1217c0:Root: 000000002070f040(System.Object[])->

00000000108c9ac0(System.Collections.Hashtable+SyncHashtable)->

00000000108c91e8(System.Collections.Hashtable)->

000000001171efc0(System.Collections.Hashtable+bucket[])->

00000000120a3768(System.Collections.Hashtable)->

00000000120a37c0(System.Collections.Hashtable+bucket[])->

00000000120a3820(System.Collections.Hashtable)->

00000000120fa180(System.Collections.Hashtable+bucket[])->

00000000120b7200(System.Collections.Generic.Dictionary`2[[ATOM.AS.CobolBase.CobolProgramName, ATOM.AS.CobolBase],[ATOM.AS.CobolBase.CobolProgram, ATOM.AS.CobolBase]])->

00000000120b7360(System.Collections.Generic.Dictionary`2+Entry[[ATOM.AS.CobolBase.CobolProgramName, ATOM.AS.CobolBase],[ATOM.AS.CobolBase.CobolProgram, ATOM.AS.CobolBase]][])->

00000000120b7258(ATOM.AS.CobolBase.CobolProgram)->

00000000120b7310(System.Collections.Generic.List`1[[ATOM.AS.CobolBase.IProgramEvents, ATOM.AS.CobolBase]])->

0000000019b0f918(System.Object[])->

0000000019b0f590(ATOM.AS.DataAccess.DataAccess)->

0000000019b13c40(ATOM.AS.DataAccess.ProviderSQL)->

0000000019b13d70(System.Data.SqlClient.SqlCommand)->

0000000019b15978(System.Data.SqlClient.SqlCommand+CachedAsyncState)

@2011, copyright Vamsidhar Tokala

Derive Concurent Users using Little's law

2011-08-29T04:12:00.000-07:00

The below real time example will help in deriving the concurrent users using Little's law. In the below example

Adjusted Hits, Median Think Time derived from production logs for one hour period.
Avg RT/Step is the Target Response SLA required to met under load
No of Steps is no of transactions per business flow
Concurrent Users is derived using little's law Throughput* (Avg RT+ Think Time)

@2011, copyright Vamsidhar Tokala

Performance Tuning Tips using Oracle Indexes

2011-06-17T02:25:00.000-07:00

1) Consider indexing keys that are used frequently in WHERE clauses and join tables and with high selectivity. The selectivity of an index is the percentage of rows in a table with the same value for the indexed key.

a. Good Selectivity

A table having 1000 records and one of its indexed column has 800 distinct values, then the selectivity of this index is 800 / 1000 = 0.8

b. Bad Selectivity

lf an index on a table of 1000 records had only 5 distinct values, then the index's selectivity is 5 / 1000 = 0.005 and in this case a query which uses the limitation of such an index will return 1000 / 5 = 200 records for each distinct value. Full table scan is better than an indexed scan in this scenario

2) Oracle database does not create an index for foreign key constraint automatically. If foreign key column often used in join conditions then create an index on them to enhance the join process

3) Consider indexing foreign keys for referential integrity constraints in cases where large number of concurrent inserts updates and delete statements access the parent and client tables. Indexing foreign key columns helps avoid full table scans when searching for the matching rows in the child table when DML is performed on parent table. Without an index in the child table a table level lock may occur

4) When choosing to index a key, consider whether the performance gain for queries is worth the performance loss of inserts, updates and deletes and use of space required storing the index.

5) Deleting a row from a table in the oracle database results in the deletion of the index entry. Updates to the key columns result in a logical deletion and insertion of index.

6) It is recommended that after periods of high DML activity, you verify index statistics and reorganize indexes
Select used, monitoring,
From v$object_usage where index_name =name of the index

White Paper - Java RMI Communication with LoadRunner

2011-04-23T01:48:00.000-07:00

Java RMI Communication with LoadRunner

Vamsidhar Tokala

This paper provides tips and tricks for HP LoadRunner JAVA RMI configuration, scripting, and execution. This guide is intended to help testers to understand the concepts of Java RMI and to use HP LoadRunner for Java RMI Scripting using Java Record and Replay protocol.

Introduction

LoadRunner is one of the very few tools available in the market which supports Java RMI protocol. Information and the expertise available in the public domain is very limited for this protocol and developing test scripts for applications that use RMI involves Java programming, and requires understanding of the Java classes involved in client/server communications. This article will enable testers with a solid background to address the challenges ahead.

Java RMI

JAVA RMI is distributed object protocol for communication between distributed objects. It provides infrastructure services such as error, exceptional handling, parameter passing and security context. Client stubs and server skeletons are generated automatically and act as an interface between the application and the rest of the RMI system.

When a client invokes a call to a business object, it needs to get a remote object reference (Stub) to the remote object (skeleton), which intercepts the call and invokes the corresponding method. Remote objects works with container to execute resource management strategies such as instance pooling and provide support for transaction persistence and security

The way client gets a remote reference to an object is by first looking up home interface of the object via JNDI(Java Naming And Directory Interface) and then invoke create method defined in the home interface. If the object client wants to call already exists, then client can invoke one of the find methods defined in the home interface after the JNDI lookup. Server typically provides a naming server for the clients to look up objects deployed on it.

When a client invokes a method call of an object of an application deployed in the server, client actually invokes a corresponding method call on a local proxy (Stub) of the object deployed in server. Local proxy serializes the parameters of the call and sends them to server side proxy (Skeleton). Skeleton collaborates with the container to provide middle ware services such as concurrency control, connection pooling. Once the call is processed, results will be returned to Skeleton, stub and then to client eventually.

RMI Communication with LoadRunner

LoadRunner will act as a client stub during RMI communication with the server. It acts like a proxy of the object on the server side. It sends the method call to the Skeleton, which is present on the server side.

When remote calls from separate clients are placed (executing in different JVMs) each call will run in a separate thread. However, if you make concurrent calls from the same client then calls will execute on the same server thread.

Configure LoadRunner’s Java RMI recorder

In order to allow LoadRunner to capture RMI communication with the application ensure the following is done

1. Install JDK. JRE alone is not sufficient for LoadRunner to record the RMI communication

2. Identify the jar files required for the application to run. Do the following steps to determine the same

· Manually access the application through browser/batch file.

· Go to Control Panel – java – Temporary internet files – Settings - Select View applications - Show JNLP Descriptor

3. Download all the jar files listed in the jnlp file to a local folder from the application server (Refer JNLP section to look at a sample file). Alternatively look in the Java console for all JARs downloaded to the cache, and copy these to a local directory.(When an application lunches from the browser a copy of all the jar will get downloaded to a temporary directory in local machine.)

4. Get all the application properties and parameters in JNLP file (see below for a sample format)

5. Create the Java security policy file - d:\all.policy - with contents:

grant {

permission java.security.AllPermission;

};

The java.security.AllPermission is a permission that implies all other permissions. Granting AllPermission should be done with extreme care. Thus, it grants code the ability to run with security disabled. Extreme caution should be taken before granting such permission to code. This permission should be used only during testing.

6. Configure class path in the environment variables for all the jar files in the local folder plus

\bin

classes

\classes\srv

\jre\lib\rt.jar

b) Set %PATH% to point to the JDK and verify this with java -version

7. Create a batch file with the information available from JNLP file as shown below

-Djava.security.policy=d:\all.policy

-DUSE_JAAS="false" -Dclient_master.properties="/retek/client_master.properties"

-Xms256M -Xmx256M

-Djava.naming.provider.url="opmn:ormi://XXX:6007:XXX-rpm/rpm12"

-DNAMING_URL="opmn:ormi://XXX:6007:XXX-rpm/rpm12"

-Djava.naming.factory.initial="oracle.j2ee.rmi.RMIInitialContextFactory"

-DNAMING_FACTORY="oracle.j2ee.rmi.RMIInitialContextFactory"

com.retek.rpm.gui.security.RpmUIClient

8. Run the batch file in the local machine. It should invoke the application with out any issues. In case of any issues while lunching the application using batch file, relook at all the steps from 1 to 8.

9. LoadRunner has predefined hooks for Java RMI called rmi.hooks which is present Dat folder of LoadRunner installation directory. The LoadRunner recorder uses these hooks to capture all Java classes as they are loaded into the Java Virtual Machine (JVM). When ever a hooks method is called, the same will be recorded into LoadRunner Script.

To enable hooks, just remove ‘;’ character present is rmi.hooks file located at \dat & \classes directories.

Customized hooks for any classes or methods specific to the application can also be created with a filename called user.hooks and place it under LoadRunner/classes directory.

10. Under LoadRunner recording options: Configure the class path as in step 6 and add each of the jar files in the same order as in JNLP file (which is very important) in LoadRunner recording options.

11. Compile and run the empty Java script with out errors.

12. Record the application either with the java application by specifying the application parameters defined in the batch file or by selection the application type as batch file. LoadRunner launches the application and captures the methods and classes defined in the hooks file.

Script Parameterization

1. Typical LoadRunner functions like vuser_init(); vuser_end() will not have any impact in the script. So after the script is recorded move the login part of the application code to init () function and logout to end () and the rest in action () function of the script.

· init() method will be called once in the beginning of the run

· action() method will be called once per each iteration

· end() method will be called once at the end of the run

2. Parameters defined in the script should assign to java objects as shown below for different data types

· String promotionEventDescription = "";

· com.retek.platform.util.type.RDate promotionEventStartDate = new com.retek.platform.util.type.RDate ("", "MM/dd/yyyy"); //application specific date object

· long departmentId = Long.parseLong("");//long

· String departmentDisplayId = ""; //string

Serialization and De serialization

During the recording process LoadRunner automatically serializes the objects. Serialized objects are flattened into bytes and subsequently inflated in the future. LoadRunner saves the objects into binary files with sequentially numbered and saved under LoadRunner Vuser directory. First file will be named as 1 and the second file as 2 and so on...

These classes captured in the script are serialized and deserialized during replay. The below example code is generated by VuGen

_object_array83 = new java.lang.Object[] {_clientcontext1, _tslcascadesearchcriteriaimpl1}; // IDLSequence

_string22 = "com.retek.rpm.app.item.service.TslCascadeSearchCriteriaImpl __CURRENT_OBJECT = {" +

"}";

_class10 = (java.lang.Class)lr.deserialize(_string22,21); // RMIComponent

_class_array27 = new java.lang.Class[] {_class1, _class10}; // IDLSequence

_object27 = _rpmcommandexecutionserviceremote27.executeCommand("com.retek.rpm.app.item.service.TslCascadeAppService", "findItems", (java.lang.Object[])_object_array83, (java.lang.Class[])_class_array27);

)

Forms of deserialization

There are two forms of deserialization used in LoadRunner.

lr.deserialize (int, boolean)
First form uses the int argument and it takes the Sequence number of the serialized object of the file saved under LoadRunner Vuser directory. If the boolean flag for the second argument is true, it uses LoadRunner's serialization method. If it is false, it uses Java's standard serialization method.
LoadRunner only unfolds objects when you are using LoadRunner's mechanism, (lr.deserialize(int, true)) and when the size of the object is smaller than the limit specified in the recording options. In cases where, for complication purposes, the object cannot be made sense out of or is larger than the size limit, LoadRunner automatically folds the object into serialbytexx.dat; sometimes it uses Java's standard mechanism, and therefore, it does not unfold the objects inside the script.
lr.deserialize(String, int)
The second form records the serialized object inside the script source as a string and uses that as the object to be deserialized. In the below example _string15 will be used as an object to be deserialized

_rpmcommandexecutionserviceremote23 = _rpmcommandexecutionserviceremotehome45.create();

_string15 = "com.retek.platform.bo.IdentifiableReference __CURRENT_OBJECT = {" +

"com.retek.platform.bo.ObjectId objectId = {" +

"java.lang.Long value = {" +

"super = {" +

"}" +

"long value = #1#" +

"}" +

"java.lang.String referencedClassName = #com.retek.rpm.domain.zonestructure.bo.ZoneGroupImpl#" +

"java.lang.Long version = {" +

"super = {" +

"}" +

"long value = #0#" +

"}" +

"}";

_identifiablereference1 = (com.retek.platform.bo.IdentifiableReference)lr.deserialize(_string15,14); // RMIComponent

Having the larger serialized object inside the script source as a string is not recommended unless correlation is needed to the object. The bigger the Java serialized object, the more memory the JVM will need for VuGen to record it as unfolded. Thus, the recording may simply crash if "Object Size limit" is set to be too high in the recording options.

To increase/decrease the object size for serialization can be set through Recording options -Serialization tab - Limit Object Size

Correlation

Correlation for the serialized objects inside the script is straight forward. In the below example, the below value 14548 is replaced by a variable

_string32_StringBuffer.append("java.util.ArrayList __CURRENT_OBJECT = {" +

"}" +

"com.retek.platform.bo.IdentifiableReference promotionReference = {" +

"com.retek.platform.bo.ObjectId objectId = {" +

"java.lang.Long value = {" +

"super = {" +

"}" +

//"long value = #14548#" +

"long value = ##" +

"}" +

Object Inspection

In case you need to inspect an object from the script then import pf-joi-full.jar in LoadRunner and add following lines:

_clientcontext1 = com.retek.platform.service.ClientContext.getInstance();

org.pf.joi.Inspector.inspect(_clientcontext1);

This will popup a window of JOI (Java Object Inspector) and you will see all members and data of the object

References

Enterprise Java Bean Response Time analysis – Santoshan Kumaran, Te-kai Liu

http://www.devarticles.com/c/a/Java/An-Introduction-To-RMI-With-Java/

http://www.oracle.com/technetwork/java/javase/tech/index-jsp-136424.html

http://www.myloadtest.com/loadrunner-tips-for-corba

http://www.cs.swan.ac.uk/~csneal/InternetComputing/RM2.html

http://www.comp.lancs.ac.uk/~weerasin/csc253/tutorials/week7.html

http://download.oracle.com/javase/1.4.2/docs/guide/security/permissions.html

http://grids.ucs.indiana.edu/ptliupages/projects/HPJava/theses/slim/dissertation/dissertation/node11.html

Debugging SAP scripts using SAPGUI Spy in LoadRunner

2010-09-02T00:36:00.000-07:00

SAPGUI Spy tool comes with LoadRunner installation and be can used to identify each of the SAP GUI Client objects. It will help to understand the properties of the objects while creating and debugging the SAP LoadRunner scripts.

LoadRunner stores the properties of the objects used in the script in lr_strings.h header file

Usage of the tool is explained using the following Code snippet

The below is a sample code which presses 'Yes' button in a pop up window. and the script failed to press the button during execution.

sapgui_select_active_window("wnd[1]");

sapgui_press_button("Yes",

btnSPOP1,

BEGIN_OPTIONAL,

"AdditionalInfo=sapgui1036",

END_OPTIONAL);;

Property for button btnSPOP1 is defined in lr_strings.h as below

const char* btnSPOP1=

"usr/btnSPOP-OPTION1";

Property of the btnSPOP1 button is replaced with the below property in lr_strings.h after verifying the using SAPGUI Spy tool as shown the snapshot below

const char* btnSPOP1=

"/app/con[0]/ses[0]/wnd[1]/usr/btnSPOP-OPTION1";

SAP GUI

Tool can be found under the following path
Additional Components\SAP_Tools\SapGuiSpy

File Transfer Errors during initialization in LoadRunner Controller

2010-08-16T05:02:00.000-07:00

File Transfer Errors are very common during initialization of load test with LoadRunner. It can be because of following reasons.

1. There may be situations where some of the runtime files of the script are not included by the controller while transferring files to different load generators (may be a bug in controller). It may not transfer all the files required for the script to run successfully. Under those situations if the scripts give compilation errors in different load generators other than local host then manually add the missing files using Add button shown in the snapshot below.

Controller Group Information

2. If the Length of the script name is too large then LoadRunner will throw error messages like below

Error: Mercury File Transfer error: Cannot create file C:\Documents and Settings\autodesk-admin\Local Settings\Temp\brr_mYv.195\netdir\C\Performance_Test\QAAutomation\Performance\LR\Stage\700ExodusSFDC\CallCenter\CC_SFDC_CreateGSSRequest_fromContactScreen_Attachment\CC_SFDC_CreateGSSRequest_fromContactScreen_Attachment.prm. Reason : Check the file path for illegal characters or length.

To double check if the length is the issue, go the LoadGenerator and try to add the file in the specified path. You may get the error as below

Error Copying File

How to determine the speed of network during a load test using LoadRunner

2010-07-14T04:59:00.000-07:00

Sometimes problems in the Network can impact load test results. It is important to monitor the rate at which data is received from the server in a Network.

LoadRunner can help you in determining the bandwidth used during a load test. Web Page Diagnostics Graphs in LoadRunner provides drill down analysis across different layers.

Network bandwidth by a Component = Component Size/ Component Receive Time

Component Receive Time is the Time to transfer between the first byte to the last byte arrives from the server and Component Size is the size of component downloaded from the server.

In the below Example Network speed during the test is 263.249/1.132 = 232 KB/sec. This speed may slight vary from component to component and also based on Load Generators used for the test

Web page diagnostics

Performance Testing in Cloud

2010-06-07T01:57:00.000-07:00

Factors which needs to considered while defining performance strategy in Cloud

Elasticity:

Elasticity is the ability to scale up your system resources when needed, and scale down when not required. Here are two important measures of cloud elasticity: spin-up elasticity and spin-down elasticity.

Load testing always consider peak load scenarios while measuring the system performance where as in cloud we may also have to consider Peak, moderate and low level usage of transactions. Base lining the System performance under these various loads will help the administrator to take a decision while scaling up or scaling down the resources based on load.

Scalability

Scalability is the ability of an application to handle increased processing demand with increase of load.

Testing the scalability of an application is very important; if the application is not scalable then the elasticity of the cloud can actually cost thousands of dollars. When moving to the cloud, it becomes even important to test the applications and to tune them properly so they are optimized when it comes to hardware consumption

Bandwidth

Usually Cloud Providers are distributed across different geographical locations. Bandwidth testing using tools like Shunra Cloud will help to ensure bandwidth requirements between the endusers and the cloud provider

Some Cloud Platform providers provide the following usage information of your application this can also be used as a basis while defining performance strategy

• CPU

• Memory

• # of DML statements

• # webservice calls

• # Calculations

Testing RESTful Web Services using LoadRunner

2010-05-06T01:05:00.000-07:00

Brief overview of RESTful web services

REST defines a set of architectural principles by which you can design Web services that focus on a system's resources, including how resource states are addressed and transferred over HTTP by a wide range of clients written in different languages. If measured by the number of Web services that use it. REST has had such a large impact on the Web that it has mostly displaced SOAP- and WSDL-based interface design because it's a considerably simpler style to use.

From the standpoint of client applications addressing resources, the URIs determine how intuitive the REST Web service is going to be and whether the service is going to be used in ways that the designers can anticipate. A third RESTful Web service characteristic is all about the URIs.

REST Web service URIs should be intuitive to the point where they are easy to guess. Think of a URI as a kind of self-documenting interface that requires little, if any, explanation or reference for a developer to understand what it points to and to derive related resources. To this end, the structure of a URI should be straightforward, predictable, and easily understood.

One way to achieve this level of usability is to define directory structure-like URIs. This type of URI is hierarchical, rooted at a single path, and branching from it are subpaths that expose the service's main areas. According to this definition, a URI is not merely a slash-delimited string, but rather a tree with subordinate and superordinate branches connected at nodes. For example, in a discussion threading service that gathers topics ranging from Java to paper, you might define a structured set of URIs like this:

http://www.myservice.org/discussion/topics/{topic}

(Refer this article written by Alex Rodriguez on RESTful webservices for more information)

Sumilating RESTful web Services using LoadRunner

REST Services can be scripted using web_custom_request by adding appropriate headers using web_add_header function before the web_custom_request.

An example for REST services script is given below.

/*********************************

web_add_header ("X-ELS-APIKey","11111");

web_add_header ("X-Forwarded-For","12.5.28.133");

web_add_header ("Accept","text/xml");

web_custom_request("web_custom_request",

"URL=http://host:8080/content/abstract/*********",

"Method=POST",

"TargetFrame=",

"EncType=text/xml; charset=iso-8859-1",

"Resource=0",

"Referer=",

"Mode=HTTP",

"Body=",

LAST);

*****************************/

If you want to verify the response manually, you need to set up the header values first in your browser.

Please find below the steps for setting up the header using mozilla firefox browser.

Open firefox. Click "Add-ons" from tools menu
Click "get Add-ons" tab.
Type "HTTP header" in the text box for search all add-ons and enter.
In search results, click on "Add to firefox" for "Modify Headers 0.6.6" and install. Now you can see "Modify Headers 0.6.6" in the extension tab.
Click on "Modify Headers 0.6.6" from the "Extensions" tab and select the check box for "Always on" and "Open modify header in a new tab" and close.
Now click "Modify headers" from the firefox tools menu and add the appropriate header name and value for your request.

Now launch the URL in the firefox browser and verify the response manually.

Also refer RESTClient addon available for firefox to test RESTful services

SAP BPC ToolKit for LoadRunner

2010-04-28T02:38:00.000-07:00

This attached guide describes the process of using LoadRunner with SAP BusinessObjects Planning and Consolidation in detail.

DownLoad SAP BPC ToolKIT from the link below
http://docs.google.com/leaf?id=0BzOftuUbGkRvZGIzOTJhZTctNzQ3Ny00MmZhLTllY2EtNDY5Y2JjZDA5Yjk3&hl=en

Download LoadRunner Guide to test SAP BPC Application
docs.google.com/fileview?id=0BzOftuUbGkRvYzE4NjFjMzAtN2JlMi00YmVjLThkMDgtNDg4ZmRlN2NjZjJm&hl=en

Client Side certificates with LoadRunner

2010-04-23T01:43:00.000-07:00

Many applications make use of the SSL extension to the HTTP protocol that adds an encryption layer to the HTTP stack. If performance test tool can't handle SSL then you won't be able to record any transactions.
One way of increasing security is to make use of client certificates, which can be installed into the application

client before access is permitted to an application. The certificates are provided in a number of formats (typically pfx or p12) and must be made available to your performance testing tool for successful capture and replay.
Please follow the steps below to import, export the certificate in the format recommended by LoadRunner.

Import Client Certificate in Browser

1. Click Start, click Control Panel, double-click Internet Options, and then click the Content tab

2. Click Certificates.

        a)The Certificates dialog box opens.
3. Click the Personal tab, and then click Import.

        a)The Certificate Import Wizard opens.
        b)On the Welcome page, click Next.

4. On the File to Import page, click Browse, select your certificate (if necessary, select your certificate type in Files of Type drop-down menu), and then click Next.

5. On the Password page, type the certificate’s password, select Mark this key as exportable, and then click Next.

6. On the Certificate Store page, select Place all certificates in the following store, browse to the Personal certificate store (if it’s not already selected), and then click Next.

7. On the Completing the Certificate Import Wizard page, click Finish.

8. Verify that the imported certificate appears in the Personal tab of the Certificates dialog box.

Export a private key

1. Under Internet Options, and then click the Content tab.

2. Click Certificates.

       a)The Certificates dialog box opens.
3. In the Certificates dialog box, click the Personal tab, select the certificate to export, and then click Export.

       a)The Certificate Export Wizard opens.
       b)On the Welcome page, click Next.

4. On the Export Private Key page, select Yes, export the private key, and then click Next.

5. On the Export File Format page, choose Personal Information Exchange – PKCS #12 (.PFX), select Include all certificates in the certification path if possible, clear the other check boxes, and then click Next.

6. On the Password page, type and retype the certificate’s password, and then click Next.

7. On the File to Export page, type the path and name of the file to export, and then click Next.

     a)The wizard will add the .pfx extension automatically.

8. On the Completing the Certificate Export Wizard page, click Finish.

Convert .PFX to .PEM format using OpenSSL

1. Download latest version of OpenSSL from OpenSSl Website

    a. http://www.openssl.org/source/

2. Convert PFX format to PEM format using the command below

a. OPENSSL PKCS12 –in <> -out <>

b. Enter the password given while exporting the certificate

c. Enter any PEM pass phase :e:g 2222

d. Reconfirm the pass phase by typing the same number again.

Open SSL

Note: SSL utility available in LoadRunner 9.5 may crash or may not work as intended. It is better to download the utility from OpenSSL website

WebServices Security in LoadRunner

Transport Level Security

Secure Sockets Layer (SSL) is a common transport layer approach that is used to provide encryption to message layer security. If your web service URL begins with https, SSL is automatically used.

First copy the created .pem file using OpenSSL utility into LoadRunner Script folder
Set up the transport level security using the following function in LoadRunner

web_set_certificate_ex("CertFilePath=testpem1111.pem",

"CertFormat=PEM",
"KeyFilePath=testpem1111.pem",
"KeyFormat=PEM",
"Password=2222", // PEM pass phase
LAST);

Note: if a web service doesn’t uses https URL then this function is not required in VuGen

Legacy Based Security

If in addition to SSL you are using message-level security (for example a username) then you must configure the security for the message separately using the Legacy/Scenario based security model (web_service_set_security) function.

When a SOAP message sends a request, those security credentials, known as security tokens, are placed in the SOAP message. When the Web server receives the SOAP request, it does not need to send additional requests to verify the integrity of the sender. The server verifies that the credentials are authentic before letting the Web Service execute the application. By not having to go back to the source of the credentials, this significantly improves the application’s scalability

VuGen allows you to create security tokens for your script. You can create multiple tokens and set their properties. After creating a token, you use it to sign or encrypt a SOAP message. When you add a security token to a SOAP message, it is added to the SOAP message in the form of an XML element in the WS-Security SOAP header.

a. LoadRunner supports different types of security tokens. The available tokens are

Username and Password, X.509 Certificate,Kerberos Ticket, Kerberos2 Ticket, Security Context Token, andDerived Token.

The information you need to provide differs for each token

b. This following is an example of legacy based security Model using User Name and Password token in LoadRunner

web_service_set_security(
SECURITY_TOKEN, "Type=USERNAME","LogicalName=DP", "UserName=XXXXXX", "Password=XXXXX", "PasswordOptions=SendPlainText", "Add=True",
LAST);

c. X.509 Certificate: When you add an X.509 token to the Vuser script, you specify the Logical Name, Store Name, Key identifier type, Key identifier value, and Store Location arguments.

These inputs to this function can be obtained by downloading Microsoft WSE X509 certificate tool from Microsoft website

web_service_set_security(
SECURITY_TOKEN, "Type=X509", "LogicalName=MyStore", "StoreName=My",
"IDType=SubjectName", "IDValue=C=US, S=CA, L=San Rafael, O=Inc., OU=IT, CN=IT Internal", "StoreLocation=CurrentUser", "Add=True",
MESSAGE_SIGNATURE, "UseToken=MyStore",
LAST);

Scenario based Security Model

LoadRunner also supports Scenario based Security Model for WCF Services which is out of scope of this post

How to track the Application Session for Call Center and Partner center in Siebel

2010-04-18T23:11:00.000-07:00

Here are the steps to check the Application Sessions for Siebel Call Center and Partner center.

1. Login to Call center

2. Click Site Map

3. Go to Administration => Server management

4. Click Components

5. Click Query

6. Query for “eChannel Object Manager (ENU_EIDM)” which is Partner Center Application

7. Running Tasks in the below image will give the current Sessions running against that Component for each Siebel Application Server

Call Center

8. Likewise perform the same query for “Call Center Object Manager (ENU)” which is call center application

9. Running Tasks in the below image will give the current Sessions running against that Component for each Siebel Application Server

Siebel Event logs

2010-04-12T23:19:00.000-07:00

To tune performance in Siebel, you first need to get detailed events for the suspected component.

Set ‘Event Log Level’ to 5 for proper component:

1) In Call Center, navigate to Site Map > Administration Server Configuration > Components > Events

2) Highlight the component for which you wish to turn the tracing on.

3) In the lower applet, select the event type and set the log level to 5.

Siebel Event logs

Sending Emails using Blat utility in LoadRunner

2010-03-03T23:56:00.000-08:00

If there is any requirement where you may have to send hundreds of emails to the server then one option is to use a web email client to simulate the load but it has following limitations

1. Your own corporate/personal Email id need to be used in LoadRunner Script but it may fill up the mail box

2. Password credentials need to be made visible in the script.

Other option is to use Blat utility which is a third party freeware utility. It sends the contents of a file in an e-mail message using the SMTP protocol.

Download the attached blat.dll utility and create a sample script as shown below.

Action()

{
command_line_Send = (char *)malloc(1024 * sizeof(char));

if(CheckLoadBlatDLL != 0) //if return code not zero then DLL not loaded!!Reload it
{
    lr_output_message("BLAT Emailing DLL Not Loaded Successfully !!! Reloading the DLL");
    CheckLoadBlatDLL = lr_load_dll("blat.dll");
}
f1=fopen(lr_eval_string("C:\\SR_{vuser_id}.txt"), "wb+" );
fprintf(f1,lr_eval_string("Email Performace Testing {TimeStamp}"));
fclose(f1);

//Initialize all the command line parameters for Blat tool

strcpy(DestEmailID,lr_eval_string("{EmailId} ")); // Destination Email ID
strcpy(Subject,lr_eval_string("\"Email PerfTesting{TimeStamp}\" ")); // EmailID Subject
strcpy(SMTPServer,lr_eval_string("{SMTPServer}")); //Your Corporate SMTP Server
strcpy(FromEmailID,lr_eval_string("{FromEmailID} "));// Source Email Id
strcpy(AttachFile,"C:\\attach.pdf "); // Any attachment
strcpy(BodyText,lr_eval_string("C:\\SampleBody{vuser_id}.txt "));// Email Body
lr_output_message("The Destination EmailId is :%s",lr_eval_string("{EmailId}"));

//Verify whether DLL Loaded successfully

if (CheckLoadBlatDLL == 0) //if return code not zero then not DLL not loaded
{
    lr_output_message("BLAT Emailing DLL Loaded Successfully ");
   // Build the Command line for sending Emails
   strcpy( command_line_Send, BodyText);
    // strcat( command_line_Send, "-attach ");
   //strcat( command_line_Send, AttachFile);
   strcat( command_line_Send, "-to ");
   strcat( command_line_Send, DestEmailID);
   strcat( command_line_Send, "-f ");
   strcat( command_line_Send, FromEmailID);
   strcat( command_line_Send, "-s ");
   strcat( command_line_Send, Subject);
   strcat( command_line_Send, "-server ");
   strcat( command_line_Send, SMTPServer);
   lr_output_message("Parameters for Send Command : %s", command_line_Send);
   temp_error_code = Send(command_line_Send);
   lr_output_message("Return code of Send command %d " , temp_error_code);
  //Check successful message sending.
   if (temp_error_code == 0) {
   lr_output_message("Email Sent Successfully ");
   }
  if(temp_error_code != 0){
  switch( temp_error_code ){
  case 1:
   //Command Line Bad Argument
   //Unable to open SMTP socket
   //Command unable to write to socket
   //Server does not like To: address
   // Mail server error accepting message data
   lr_error_message("ERROR : Check the command Line Argument Format");
   break;
  case 2:
   //The server actively denied our connection.
   //The mail server doesn't like the sender name.
   lr_error_message("ERROR : Email Server Denied connection or File does not exist");
   break;
   }//end SWITCH
}//end IF
}else{
  lr_output_message("Unable to Load the Blat DLL - Check whether DLL exists at the specified location ");
}
free(command_line_Send);
return 0;
}

SAP Workload

2010-02-23T00:04:00.000-08:00

While designing a workload model for performance testing SAP application, it is important to derive details like Concurrent users, frequently used transactions and load distribution across multiple servers etc. These details can be obtained by using STO3N command at different periods of times in prod.

Figure below shows the ST03N transaction report

ST03N

1. ST03N Transaction can help in calculating volume of transactions done after the LoadTest
2. It can help in analyzing workload for different statistics like background jobs,dialog processes etc
3. It can used to identify the number of users working on an application server
4. Analyze the time spent by the transaction across different tiers in the system
5. Load Distribution across multiple servers during the loadtest

SOAP Over JMS using Publisher - Subscriber Communication

2010-01-12T03:36:00.000-08:00

Publish-Subscribe. Each message is sent from one publisher to many subscribers through a designated topic. The subscribers only receive messages sent after they have subscribed.

A sample script to Publish and Subcribe JMS messages to TIBCO using LoadRunner

Action()

{
//Sample Queue Name - TIBQ1.SAP.SyncOrder.ADSKOrder
jms_subscribe_topic("subcribe_step", "subscription_1", "TIBQ1.SAP.SyncOrder.ADSKOrder");

// Publishes messages to a specific topic
jms_publish_message_topic("Publish",

"\r\n \r\n "",

"7051170660\r\n "\r\n \r\n "

"2009-01-08

" 000000000025835109\r\n "

" \r\n

"TIBQ1.SAP.SyncOrder.ADSKOrder");

//Receives published messages to a specific topic on a subscription
jms_receive_message_topic("receive_step", "subscription_1", "TIBQ1.SAP.SyncOrder.ADSKOrder");

//Received messages are saved in the JMS_message parameter
lr_output_message(lr_eval_string("message : \n{JMS_message}\n"));

return 0;

}

JMS RuntimeSettings

JMS Runtime Settings

Integrating Sitescope Monitor with Controller

2010-01-08T22:21:00.000-08:00

To integrate a SiteScope server that needs authentication, modify the modify the LR installation folder\dat\monitors\xmlmonitorshared.ini file as follows:

1. Locate the [SiteScope] section in the file.
2. Append &account=administrator, or if you want to log in using other user (e.g., XXX), append &account=XXX, to the MetricListURL.

Note:

The user XXX must have the right permissions in SiteScope and may be different from the user name. The SiteScope server should be accessed as

http://sitescope:8888/SiteScope?account=XXX.
3. Add "QueryLoginInfo=1" at the end of the section.

With this, you should be able to see a login window when adding measurements.