HTTP::Recorder::Httperf - An HTTP::Recorder subclass to record user actions as input for httperf for load testing

HTTP-Recorder-Httperf documentation Contained in the HTTP-Recorder-Httperf distribution.

Index

Code Index:

NAME

Top

HTTP::Recorder::Httperf - An HTTP::Recorder subclass to record user actions as input for httperf for load testing

SYNOPSIS

Top

Use it almost exactly like you would use HTTP::Recorder. In fact, this synopsis comes almost exactly 'as is' from the HTTP::Recorder documentation only changing 'HTTP::Recorder' to 'HTTP::Recorder::Httperf'.

	#!/usr/bin/perl

	use HTTP::Proxy;
	use HTTP::Recorder::Httperf;

	my $proxy = HTTP::Proxy->new();

	# create a new HTTP::Recorder::Httperf object
	my $agent = new HTTP::Recorder::Httperf;

	# set the log file (optional)
	$agent->file("/tmp/myfile");

	# set HTTP::Recorder as the agent for the proxy
	$proxy->agent( $agent );

	# start the proxy
	$proxy->start();

	1;

Now let's look at our 'file' (/tmp/myfile) and it might look something like this...

	#new session definition
	/foo.html think=2.0
	    /pict1.gif
	    /pict2.gif
	/foo2.html method=POST contents=’Post data’
	    /pict3.gif
	    /pict4.gif

	#new session definition
	/foo3.html method=POST contents="Multiline\ndata"
	/foo4.html method=HEAD

This sample httperf session file comes straight from the httperf manpage. If you would like more information on the specific syntax of this file or how to edit it then please see the httperf documentation.

Then you can run httperf to load test your recorded session with something like this

	httperf --server 192.168.1.2 --wsesslog 100,2,/tmp/myfile --max-piped-calls=5 --rate 10

DESCRIPTION

Top

This module is a subclass of HTTP::Recorder but instead of recording the user's actions as a WWW::Mechanize script they are instead recorded into a session file to be used by httperf, a load testing engine for testing websevers (http://www.hpl.hp.com/personal/David_Mosberger/httperf.html).

It's use is almost exactly the same as HTTP::Recorder. Some methods have been added for convenience for httperf specific functionality. Please be familiar with HTTP::Recorder and it's documentation before proceeding to use this module as it will probably answer most of your questions.

METHODS

Top

new([%args])

This is the constuctor method. Any arguments passed into this method will passed directly to HTTP::Recorder::new() except for the 'logger' argument which will be overridden with a new HTTP::Recorder::Httperf::Logger object.

In addition to the name-value pairs that HTTP::Recorder::new takes, this method will also accept the following arguments.

default_think

This value set's the default 'think' value (time in seconds) for each request in this session (see httperf documentation). If this value isn't set (or undef) then HTTP::Recorder::Httperf will try and estimate the think time looking at the user's actual browsing. By default it is 'undef'

burst_threshold

This value set's the time in seconds between requests where they would be considered a part of a burst. If this is not set then it defaults to 1 sec.

temp_file

HTTP::Recorder::Httperf uses a temporary file to store data about the time of requests. By default this is named '.httperf_recorder_time'. You can change it as you see fit.

default_think([$value])

This accessor/mutator method will return the current value for the 'default_think' time in seconds between requests in this session. If $value is given it will set the current 'default_think' first to $value and then return it. If it hasn't been set, it will return undef.

burst_threshold([$value])

This accessor/mutator method will return the current value for the 'burst_threshold' time in seconds. See new(). If $value is given it will set the current 'burst_threshold' first to $value and then return it.

temp_file([$value])

This accessor/mutator method will return the current name of the 'temp_file'. See new(). If $value is given it will set the current 'temp_file' first to $value and then return it.

CAVEATS

Top

AUTHOR

Top

Michael Peters <mpeters@plusthree.com>

SEE ALSO

Top

httperf http://www.hpl.hp.com/personal/David_Mosberger/httperf.html, HTTP::Recorder, LWP::UserAgent, HTTP::Proxy

HTTP-Recorder-Httperf documentation Contained in the HTTP-Recorder-Httperf distribution. 
package HTTP::Recorder::Httperf;
use base 'HTTP::Recorder';
use strict;
use warnings;
use HTTP::Recorder::Httperf::Logger;
use File::Temp ();

$HTTP::Recorder::Httperf::VERSION = 0.02;

sub new
{
  my ($class, %args) = @_;

  my $default_think = $args{default_think};
  delete($args{default_think});
  my $temp_file = $args{temp_file};
  delete($args{temp_file});
  my $burst_threshold = $args{burst_threshold}; 
  delete($args{burst_threshold});

  my $self = $class->SUPER::new(%args);
  bless $self, $class;
  $self->{default_think} = $default_think || undef;
  $self->{temp_file} = $temp_file || '.httperf_recorder_time';
  $self->{burst_threshold} = $burst_threshold || 1;

  #create a new HTTP::Recorder::httper::Logger object and store it as my 'logger'
  $self->logger(HTTP::Recorder::Httperf::Logger->new(file => $args{file}));
  return $self;
}


#this is where the fun stuff of logging the httperf session file takes place
sub modify_request
{ 
  my ($self, $request) = @_;
  my ($think, $indent) = ($self->{default_think}, 0);
 
  #if we don't have the default_think time then go and get it
  if(!defined($think))
  {
    #get the current time
    my $cur_time = time();
    #get the last time a request was run
    my $last_time = $self->_get_temp_time();
    #now set think and indent
    $think = $last_time ? $cur_time - $last_time: $last_time;
    $self->_set_temp_time(time());
    #it can only be indented if it isn't the first (ie, there was a last time)
    $indent = $think <= $self->{burst_threshold} if($last_time);
  } 

  #get the uri of the request
  my $uri = $request->uri->path();
  $uri = '/' if(!$uri); #add an empty '/' if there is no path
  $uri .= '?' . $request->uri->query if($request->uri->query);
  #now log this line
  my $content = $request->content();
  if($content)
  {
    $content =~ s/\r?\n/\\<CR>/g;
    $content =~ s/"/\\"/g;
  }
  my $line = $indent ? '    ' : '';
  $line .= "$uri method=" . $request->method();
  $line .= " contents=\"$content\"" if($content);
  $line .= " think=$think" if($think && !$indent);
  $line .= "\n";
  $self->{logger}->Log($line);

  return $request;
}


sub _get_temp_time
{
  my $self = shift;
  my $line = 0;
  #open up the temp file
  if( -e $self->{temp_file})
  {
    open(FILE, $self->{temp_file}) or 
      die "Couldn't open " . $self->{temp_file} . ": $!";
    #get the time from the first line
    $line = <FILE> || 0;
    close(FILE) or die "Couldn't close " . $self->{temp_file} . ": $!";
    chomp($line) if($line);
  }
  return $line;
}


sub _set_temp_time
{
  my ($self, $time) = @_;
  #now write the time
  my $fh = File::Temp->new(TEMPLATE => '/tmp/httperf_recorder_XXXX', UNLINK => 0);
  print $fh $time;
  rename($fh->filename(), $self->{temp_file}) or 
    die "Couln't rename " . $self->{temp_file} . ": $!";
}



#just a blank method so that the response isn't modified, so just return the response
sub modify_response
{ return $_[1] }

#accessor/mutators
sub default_think 
{
  my ($self, $value) = @_;
  $self->{default_think} = $value if(defined $value);
  return $self->{default_think};
}

sub temp_file 
{
  my ($self, $value) = @_;
  $self->{temp_file} = $value if(defined $value);
  return $self->{temp_file};
}

sub burst_threshold 
{
  my ($self, $value) = @_;
  $self->{burst_threshold} = $value if(defined $value);
  return $self->{burst_threshold};
}





1;