SVN: Zope/trunk/src/Zope2/utilities/requestprofiler.py Restore the requestprofiler, Tres still relies on it
Hanno Schlichting <[email protected]>
| Newsgroups | gmane.comp.web.zope.cvs |
|---|---|
| Message-ID | <20110702202621.C5CE1941C9__31605.8126897135$1309638389$gmane$org@cvs.zope.org> |
Log message for revision 122068:
Restore the requestprofiler, Tres still relies on it
Changed:
A Zope/trunk/src/Zope2/utilities/requestprofiler.py
-=-
Copied: Zope/trunk/src/Zope2/utilities/requestprofiler.py (from rev 122057, Zope/trunk/src/Zope2/utilities/requestprofiler.py)
===================================================================
--- Zope/trunk/src/Zope2/utilities/requestprofiler.py (rev 0)
+++ Zope/trunk/src/Zope2/utilities/requestprofiler.py 2011-07-02 20:26:21 UTC (rev 122068)
@@ -0,0 +1,841 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Request log profiler script
+"""
+
+import sys, time, getopt, math, cPickle
+from types import StringType
+try: import gzip
+except: pass
+
+class ProfileException(Exception): pass
+
+class Request:
+ def __init__(self):
+ self.url = None
+ self.start = None
+ self.method = None
+ self.t_recdinput = None
+ self.isize = None
+ self.t_recdoutput = None
+ self.osize = None
+ self.httpcode = None
+ self.t_end = None
+ self.elapsed = "I"
+ self.active = 0
+
+ def put(self, code, t, desc):
+ if code not in ('A', 'B', 'I', 'E'):
+ raise "unknown request code %s" % code
+ if code == 'B':
+ self.start = t
+ self.method, self.url = desc.strip().split()
+ elif code == "I":
+ self.t_recdinput = t
+ self.isize = desc.strip()
+ elif code == "A":
+ self.t_recdoutput = t
+ self.httpcode, self.osize = desc.strip().split()
+ elif code == 'E':
+ self.t_end = t
+ self.elapsed = int(self.t_end - self.start)
+
+ def isfinished(self):
+ return not self.elapsed == "I"
+
+ def prettystart(self):
+ if self.start is not None:
+ t = time.localtime(self.start)
+ return time.strftime('%Y-%m-%dT%H:%M:%S', t)
+ else:
+ return "NA"
+
+ def shortprettystart(self):
+ if self.start is not None:
+ t = time.localtime(self.start)
+ return time.strftime('%H:%M:%S', t)
+ else:
+ return "NA"
+
+ def win(self):
+ if self.t_recdinput is not None and self.start is not None:
+ return self.t_recdinput - self.start
+ else:
+ return "NA"
+
+ def wout(self):
+ if self.t_recdoutput is not None and self.t_recdinput is not None:
+ return self.t_recdoutput - self.t_recdinput
+ else:
+ return "NA"
+
+ def wend(self):
+ if self.t_end is not None and self.t_recdoutput is not None:
+ return self.t_end - self.t_recdoutput
+ else:
+ return "NA"
+
+ def endstage(self):
+ if self.t_end is not None:
+ stage = "E"
+ elif self.t_recdoutput is not None:
+ stage = "A"
+ elif self.t_recdinput is not None:
+ stage = "I"
+ else:
+ stage = "B"
+ return stage
+
+ def total(self):
+ stage = self.endstage()
+ if stage == "B": return 0
+ if stage == "I": return self.t_recdinput - self.start
+ if stage == "A": return self.t_recdoutput - self.start
+ if stage == "E": return self.elapsed
+
+ def prettyisize(self):
+ if self.isize is not None:
+ return self.isize
+ else:
+ return "NA"
+
+ def prettyosize(self):
+ if self.osize is not None:
+ return self.osize
+ else:
+ return "NA"
+
+ def prettyhttpcode(self):
+ if self.httpcode is not None:
+ return self.httpcode
+ else:
+ return "NA"
+
+ def __str__(self):
+ body = (
+ self.prettystart(), self.win(), self.wout(), self.wend(),
+ self.total(), self.endstage(), self.prettyosize(),
+ self.prettyhttpcode(), self.active, self.url
+ )
+ return self.fmt % body
+
+ fmt = "%19s %4s %4s %4s %3s %1s %7s %4s %4s %s"
+
+ def getheader(self):
+ body = ('Start', 'WIn', 'WOut', 'WEnd', 'Tot', 'S', 'OSize',
+ 'Code', 'Act', 'URL')
+ return self.fmt % body
+
+class StartupRequest(Request):
+ def endstage(self):
+ return "U"
+
+ def total(self):
+ return 0
+
+class Cumulative:
+ def __init__(self, url):
+ self.url = url
+ self.times = []
+ self.hangs = 0
+ self.allelapsed = None
+
+ def put(self, request):
+ elapsed = request.elapsed
+ if elapsed == "I": self.hangs = self.hangs + 1
+ self.times.append(elapsed)
+
+ def all(self):
+ if self.allelapsed == None:
+ self.allelapsed = []
+ for elapsed in self.times:
+ self.allelapsed.append(elapsed)
+ self.allelapsed.sort()
+ return self.allelapsed
+
+ def __str__(self):
+ body = (
+ self.hangs, self.hits(), self.total(), self.max(), self.min(),
+ self.median(), self.mean(), self.url
+ )
+ return self.fmt % body
+
+ def getheader(self):
+ return self.fmt % ('Hangs', 'Hits', 'Total', 'Max', 'Min', 'Median',
+ 'Mean', 'URL')
+
+ fmt = "%5s %5s %5s %5s %5s %6s %5s %s"
+
+ def hits(self):
+ return len(self.times)
+
+ def max(self):
+ return max(self.all())
+
+ def min(self):
+ return min(self.all())
+
+ def mean(self):
+ l = len(self.times)
+ if l == 0:
+ return "I"
+ else:
+ t = self.total()
+ if t == "I": return "I"
+ return t/l
+
+ def median(self):
+ all = self.all()
+ l = len(all)
+ if l == 0:
+ return "I"
+ else:
+ if l == 1:
+ return all[0]
+ elif l % 2 != 0:
+ i = l/2 + 1
+ return all[i]
+ else:
+ i = l/2 - 1
+ i2 = i + 1
+ v1 = all[i]
+ v2 = all[i2]
+ if isinstance(v1, StringType) or isinstance(v2, StringType):
+ return "I"
+ else: return (v1 + v2) / 2
+
+ def total(self):
+ t = 0
+ all = self.all()
+ for elapsed in all:
+ if elapsed == "I": continue
+ t = t + elapsed
+ return t
+
+def parsebigmlogline(line):
+ tup = line.split(None, 3)
+ if len(tup) == 3:
+ code, id, timestr = tup
+ return code, id, timestr, ''
+ elif len(tup) == 4:
+ return tup
+ else:
+ return None
+
+def get_earliest_file_data(files):
+ temp = {}
+ earliest_fromepoch = 0
+ earliest = None
+ retn = None
+ for file in files:
+ line = file.readline()
+ if not line:
+ continue
+ linelen = len(line)
+ line = line.strip()
+ tup = parsebigmlogline(line)
+ if tup is None:
+ print "Could not interpret line: %s" % line
+ continue
+ code, id, timestr, desc = tup
+ timestr = timestr.strip()
+ fromepoch = getdate(timestr)
+ temp[file] = linelen
+ if earliest_fromepoch == 0 or fromepoch < earliest_fromepoch:
+ earliest_fromepoch = fromepoch
+ earliest = file
+ retn = [code, id, fromepoch, desc]
+
+ for file, linelen in temp.items():
+ if file is not earliest:
+ file.seek(file.tell() - linelen)
+
+ return retn
+
+def get_requests(files, start=None, end=None, statsfname=None,
+ writestats=None, readstats=None):
+ finished = []
+ unfinished = {}
+ if readstats:
+ fp = open(statsfname, 'r')
+ u = cPickle.Unpickler(fp)
+ requests = u.load()
+ fp.close()
+ del u
+ del fp
+ else:
+ while 1:
+ tup = get_earliest_file_data(files)
+ if tup is None:
+ break
+ code, id, fromepoch, desc = tup
+ if start is not None and fromepoch < start: continue
+ if end is not None and fromepoch > end: break
+ if code == 'U':
+ finished.extend(unfinished.values())
+ unfinished.clear()
+ request = StartupRequest()
+ request.url = desc
+ request.start = int(fromepoch)
+ finished.append(request)
+ continue
+ request = unfinished.get(id)
+ if request is None:
+ if code != "B": continue # garbage at beginning of file
+ request = Request()
+ for pending_req in unfinished.values():
+ pending_req.active = pending_req.active + 1
+ unfinished[id] = request
+ t = int(fromepoch)
+ try:
+ request.put(code, t, desc)
+ except:
+ print "Unable to handle entry: %s %s %s"%(code, t, desc)
+ if request.isfinished():
+ del unfinished[id]
+ finished.append(request)
+
+ finished.extend(unfinished.values())
+ requests = finished
+
+ if writestats:
+ fp = open(statsfname, 'w')
+ p = cPickle.Pickler(fp)
+ p.dump(requests)
+ fp.close()
+ del p
+ del fp
+
+ return requests
+
+def analyze(requests, top, sortf, start=None, end=None, mode='cumulative',
+ resolution=60, urlfocusurl=None, urlfocustime=60):
+
+ if mode == 'cumulative':
+ cumulative = {}
+ for request in requests:
+ url = request.url
+ stats = cumulative.get(url)
+ if stats is None:
+ stats = Cumulative(url)
+ cumulative[url] = stats
+ stats.put(request)
+ requests = cumulative.values()
+ requests.sort(sortf)
+ write(requests, top)
+
+ elif mode=='timed':
+ computed_start = requests[0].start
+ computed_end = requests[-1].t_end
+ if start and end:
+ timewrite(requests,start,end,resolution)
+ if start and not end:
+ timewrite(requests,start,computed_end,resolution)
+ if end and not start:
+ timewrite(requests,computed_start,end,resolution)
+ if not end and not start:
+ timewrite(requests,computed_start,computed_end,resolution)
+
+ elif mode == 'urlfocus':
+ requests.sort(sortf)
+ urlfocuswrite(requests, urlfocusurl, urlfocustime)
+
+ else:
+ requests.sort(sortf)
+ write(requests, top)
+
+def urlfocuswrite(requests, url, t):
+ l = []
+ i = 0
+ for request in requests:
+ if request.url == url: l.append(i)
+ i = i + 1
+ before = {}
+ after = {}
+ x = 0
+ for n in l:
+ x = x + 1
+ r = requests[n]
+ start = r.start
+ earliest = start - t
+ latest = start + t
+ print 'URLs invoked %s seconds before and after %s (#%s, %s)' % \
+ (t, url, x, r.shortprettystart())
+ print '---'
+ i = -1
+ for request in requests:
+ i = i + 1
+ if request.start < earliest: continue
+ if request.start > latest: break
+ if n == i: # current request
+ print '%3d' % (request.start - start),
+ print '%s' % (request.shortprettystart()),
+ print request.url
+ continue
+ if request.start <= start:
+ if before.get(i):
+ before[i] = before[i] + 1
+ else:
+ before[i] = 1
+ if request.start > start:
+ if after.get(i):
+ after[i] = after[i] + 1
+ else:
+ after[i] = 1
+ print '%3d' % (request.start - start),
+ print '%s' % (request.shortprettystart()),
+ print request.url
+ print
+ print ('Summary of URLs invoked before (and at the same time as) %s '
+ '(times, url)' % url)
+ before = before.items()
+ before.sort()
+ for k,v in before:
+ print v, requests[k].url
+ print
+ print 'Summary of URLs invoked after %s (times, url)' % url
+ after = after.items()
+ after.sort()
+ for k,v in after:
+ print v, requests[k].url
+
+def write(requests, top=0):
+ if len(requests) == 0:
+ print "No data.\n"
+ return
+ i = 0
+ header = requests[0].getheader()
+ print header
+ for stat in requests:
+ i = i + 1
+ if verbose:
+ print str(stat)
+ else:
+ print str(stat)[:78]
+ if i == top:
+ break
+
+def getdate(val):
+ try:
+ val = val.strip()
+ year, month, day = int(val[:4]), int(val[5:7]), int(val[8:10])
+ hour,minute,second=int(val[11:13]),int(val[14:16]),int(val[17:19])
+ t = time.mktime((year, month, day, hour, minute, second, 0, 0, -1))
+ return t
+ except:
+ raise ProfileException, "bad date %s" % val
+
+def getTimeslice(period, utime):
+ low = int(math.floor(utime)) - period + 1
+ high = int(math.ceil(utime)) + 1
+ for x in range(low, high):
+ if x % period == 0:
+ return x
+
+def timewrite(requests, start, end, resolution):
+ print "Start: %s End: %s Resolution: %d secs" % \
+ (tick2str(start), tick2str(end), resolution)
+ print "-" * 78
+ print
+ print "Date/Time #requests requests/second"
+
+ d = {}
+ max = 0
+ min = None
+ for r in requests:
+ t = r.start
+ slice = getTimeslice(resolution,t)
+ if slice > max: max = slice
+ if (min is None) or (slice < min): min = slice
+ if d.has_key(slice):
+ d[slice] = d[slice] + 1
+ else:
+ d[slice] = 1
+
+ num = 0
+ hits = 0
+ avg_requests = None
+ max_requests = 0
+ for slice in range(min, max, resolution):
+ num = d.get(slice, 0)
+ if num>max_requests: max_requests = num
+ hits = hits + num
+
+ if avg_requests is None:
+ avg_requests = num
+ else:
+ avg_requests = (avg_requests + num) / 2
+
+ s = tick2str(slice)
+ s = s + " %6d %4.2lf" % (num,num*1.0/resolution)
+ print s
+
+ print '='*78
+ print " Peak: %6d %4.2lf" % \
+ (max_requests,max_requests*1.0/resolution)
+ print " Avg: %6d %4.2lf" % \
+ (avg_requests,avg_requests*1.0/resolution)
+ print "Total: %6d n/a " % (hits)
+
+def tick2str(t):
+ return time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime(t))
+
+def codesort(v1, v2):
+ v1 = v1.endstage()
+ v2 = v2.endstage()
+ if v1 == v2:
+ return 0
+
+ if v1 == "B":
+ return -1 # v1 is smaller than v2
+ if v1 == "I":
+ if v2 == "B": return 1 # v1 is larger than v2
+ else: return -1
+ if v1 == "A":
+ if v2 in ['B', 'I']: return 1
+ else: return -1
+ if v1 == "E":
+ return 1
+
+class Sort:
+ def __init__(self, fname, ascending=0):
+ self.fname = fname
+ self.ascending = ascending
+
+ def __call__(self, i1, i2):
+ f1 = getattr(i1, self.fname)
+ f2 = getattr(i2, self.fname)
+ if callable(f1): f1 = f1()
+ if callable(f2): f2 = f2()
+ if f1 < f2:
+ if self.ascending: return -1
+ else: return 1
+ elif f1 == f2:
+ return 0
+ else:
+ if self.ascending: return 1
+ else: return -1
+
+def detailedusage():
+ details = usage(0)
+ pname = sys.argv[0]
+ details = details + """
+Reports are of four types: cumulative, detailed, timed, or urlfocus. The
+default is cumulative. Data is taken from one or more Zope detailed request
+logs (-M logs, aka 'big M' logs) or from a preprocessed statistics file.
+
+For cumulative reports, each line in the profile indicates information
+about a Zope method (URL) collected via a detailed request log.
+
+For detailed reports, each line in the profile indicates information about
+a single request.
+
+For timed reports, each line in the profile indicates informations about
+the number of requests and the number of requests/second for a period of time.
+
+For urlfocus reports, ad-hoc information about requests surrounding the
+specified url is given.
+
+Each 'filename' is a path to a '-M' log that contains detailed request data.
+Multiple input files can be analyzed at the same time by providing the path
+to each file. (Analyzing multiple big M log files at once is useful if you
+have more than one Zope client on a single machine and you'd like to
+get an overview of all Zope activity on that machine).
+
+If you wish to make multiple analysis runs against the same input data, you
+may want to use the --writestats option. The --writestats option creates a
+file which holds preprocessed data representing the specfified input files.
+Subsequent runs (for example with a different sort spec) will be much
+faster if the --readstats option is used to specify a preprocessed stats
+file instead of actual input files because the logfile parse step is skipped.
+
+If a 'sort' value is specified, sort the profile info by the spec. The sort
+order is descending unless indicated. The default cumulative sort spec is
+'total'. The default detailed sort spec is 'start'.
+
+For cumulative reports, the following sort specs are accepted:
+
+ 'hits' -- the number of hits against the method
+ 'hangs' -- the number of unfinished requests to the method
+ 'max' -- the maximum time in secs taken by a request to this method
+ 'min' -- the minimum time in secs taken by a request to this method
+ 'mean' -- the mean time in secs taken by a request to this method
+ 'median' -- the median time in secs taken by a request to this method
+ 'total' -- the total time in secs across all requests to this method
+ 'url' -- the URL/method name (ascending)
+
+For detailed (non-cumulative) reports, the following sort specs are accepted:
+
+ 'start' -- the start time of the request to ZServer (ascending)
+ 'win' -- the num of secs ZServer spent waiting for input from client
+ 'wout' -- the secs ZServer spent waiting for output from ZPublisher
+ 'wend' -- the secs ZServer spent sending data to the client
+ 'total' -- the secs taken for the request from begin to end
+ 'endstage' -- the last successfully completed request stage (B, I, A, E)
+ 'osize' -- the size in bytes of output provided by ZPublisher
+ 'httpcode' -- the HTTP response code provided by ZPublisher (ascending)
+ 'active' -- total num of requests pending at the end of this request
+ 'url' -- the URL/method name (ascending)
+
+For timed and urlfocus reports, there are no sort specs allowed.
+
+If the 'top' argument is specified, only report on the top 'n' entries in
+the profile (as per the sort). The default is to show all data in the profile.
+
+If the 'verbose' argument is specified, do not trim url to fit into 80 cols.
+
+If the 'today' argument is specified, limit results to hits received today.
+
+If the 'daysago' argument is specified, limit results to hits received n days ago.
+
+The 'resolution' argument is used only for timed reports and specifies the
+number of seconds between consecutive lines in the report
+(default is 60 seconds).
+
+The 'urlfocustime' argument is used only for urlfocus reports and specifies the
+number of seconds to target before and after the URL provided in urlfocus mode.
+(default is 10 seconds).
+
+If the 'start' argument is specified in the form 'DD/MM/YYYY HH:MM:SS' (UTC),
+limit results to hits received after this date/time.
+
+If the 'end' argument is specified in the form 'DD/MM/YYYY HH:MM:SS' (UTC),
+limit results to hits received before this date/time.
+
+'start' and 'end' arguments are not honored when request stats are obtained
+via the --readstats argument.
+
+Examples:
+
+ %(pname)s debug.log
+
+ Show cumulative report statistics for information in the file 'debug.log',
+ by default sorted by 'total'.
+
+ %(pname)s debug.log --detailed
+
+ Show detailed report statistics sorted by 'start' (by default).
+
+ %(pname)s debug.log debug2.log --detailed
+
+ Show detailed report statistics for both logs sorted by 'start'
+ (by default).
+
+ %(pname)s debug.log --cumulative --sort=mean --today --verbose
+
+ Show cumulative report statistics sorted by mean for entries in the log
+ which happened today, and do not trim the URL in the resulting report.
+
+ %(pname)s debug.log --cumulative --sort=mean --daysago=3 --verbose
+
+ Show cumulative report statistics sorted by mean for entries in the log
+ which happened three days ago, and do not trim the URL in the resulting report.
+
+ %(pname)s debug.log --urlfocus='/manage_main' --urlfocustime=60
+
+ Show 'urlfocus' report which displays statistics about requests
+ surrounding the invocation of '/manage_main'. Focus on the time periods
+ 60 seconds before and after each invocation of the '/manage_main' URL.
+
+ %(pname)s debug.log --detailed --start='2001/05/10 06:00:00'
+ --end='2001/05/11 23:00:00'
+
+ Show detailed report statistics for entries in 'debug.log' which
+ begin after 6am UTC on May 10, 2001 and which end before
+ 11pm UTC on May 11, 2001.
+
+ %(pname)s debug.log --timed --resolution=300 --start='2001/05/10 06:00:00'
+ --end='2001/05/11 23:00:00'
+
+ Show timed report statistics for entries in the log for one day
+ with a resolution of 5 minutes
+
+ %(pname)s debug.log --top=100 --sort=max
+
+ Show cumulative report of the the 'top' 100 methods sorted by maximum
+ elapsed time.
+
+ %(pname)s debug.log debug2.log --writestats='requests.stat'
+
+ Write stats file for debug.log and debug2.log into 'requests.stat' and
+ show default report.
+
+ %(pname)s --readstats='requests.stat' --detailed
+
+ Read from 'requests.stat' stats file (instead of actual -M log files)
+ and show detailed report against this data.""" % {'pname':pname}
+ return details
+
+def usage(basic=1):
+ usage = (
+ """
+Usage: %s filename1 [filename2 ...]
+ [--cumulative | --detailed | [--timed --resolution=seconds]]
+ [--sort=spec]
+ [--top=n]
+ [--verbose]
+ [--today | [--start=date] [--end=date] | --daysago=n ]
+ [--writestats=filename | --readstats=filename]
+ [--urlfocus=url]
+ [--urlfocustime=seconds]
+ [--help]
+
+Provides a profile of one or more Zope "-M" request log files.
+""" % sys.argv[0]
+ )
+ if basic == 1:
+ usage = usage + """
+If the --help argument is given, detailed usage docs are provided."""
+ return usage
+
+
+def main():
+ if len(sys.argv) == 1:
+ print usage()
+ sys.exit(0)
+ if sys.argv[1] == '--help': print detailedusage(); sys.exit(0)
+ mode = 'cumulative'
+ sortby = None
+ trim = 0
+ top = 0
+ verbose = 0
+ start = None
+ end = None
+ resolution=60
+ urlfocustime=10
+ urlfocusurl=None
+ statsfname = None
+ readstats = 0
+ writestats = 0
+
+ files = []
+ i = 1
+ for arg in sys.argv[1:]:
+ if arg[:2] != '--':
+ if arg[-3:] == '.gz' and globals().has_key('gzip'):
+ files.append(gzip.GzipFile(arg,'r'))
+ else:
+ files.append(open(arg))
+ sys.argv.remove(arg)
+ i = i + 1
+
+ try:
+ opts, extra = getopt.getopt(
+ sys.argv[1:], '', ['sort=', 'top=', 'help', 'verbose', 'today',
+ 'cumulative', 'detailed', 'timed','start=',
+ 'end=','resolution=', 'writestats=','daysago=',
+ 'readstats=','urlfocus=','urlfocustime=']
+ )
+ for opt, val in opts:
+
+ if opt=='--readstats':
+ statsfname = val
+ readstats = 1
+ elif opt=='--writestats':
+ statsfname = val
+ writestats = 1
+ if opt=='--sort': sortby = val
+ if opt=='--top': top=int(val)
+ if opt=='--help': print detailedusage(); sys.exit(0)
+ if opt=='--verbose':
+ verbose = 1
+ if opt=='--resolution':
+ resolution=int(val)
+ if opt=='--today':
+ now = time.localtime(time.time())
+ # for testing - now = (2001, 04, 19, 0, 0, 0, 0, 0, -1)
+ start = list(now)
+ start[3] = start[4] = start[5] = 0
+ start = time.mktime(start)
+ end = list(now)
+ end[3] = 23; end[4] = 59; end[5] = 59
+ end = time.mktime(end)
+ if opt=='--daysago':
+ now = time.localtime(time.time() - int(val)*3600*24 )
+ # for testing - now = (2001, 04, 19, 0, 0, 0, 0, 0, -1)
+ start = list(now)
+ start[3] = start[4] = start[5] = 0
+ start = time.mktime(start)
+ end = list(now)
+ end[3] = 23; end[4] = 59; end[5] = 59
+ end = time.mktime(end)
+ if opt=='--start':
+ start = getdate(val)
+ if opt=='--end':
+ end = getdate(val)
+ if opt=='--detailed':
+ mode='detailed'
+ d_sortby = sortby
+ if opt=='--cumulative':
+ mode='cumulative'
+ if opt=='--timed':
+ mode='timed'
+ if opt=='--urlfocus':
+ mode='urlfocus'
+ urlfocusurl = val
+ if opt=='--urlfocustime':
+ urlfocustime=int(val)
+
+ validcumsorts = ['url', 'hits', 'hangs', 'max', 'min', 'median',
+ 'mean', 'total']
+ validdetsorts = ['start', 'win', 'wout', 'wend', 'total',
+ 'endstage', 'isize', 'osize', 'httpcode',
+ 'active', 'url']
+
+ if mode == 'cumulative':
+ if sortby is None: sortby = 'total'
+ assert sortby in validcumsorts, (sortby, mode, validcumsorts)
+ if sortby in ['url']:
+ sortf = Sort(sortby, ascending=1)
+ else:
+ sortf = Sort(sortby)
+ elif mode == 'detailed':
+ if sortby is None: sortby = 'start'
+ assert sortby in validdetsorts, (sortby, mode, validdetsorts)
+ if sortby in ['start', 'url', 'httpcode']:
+ sortf = Sort(sortby, ascending=1)
+ elif sortby == 'endstage':
+ sortf = codesort
+ else:
+ sortf = Sort(sortby)
+ elif mode=='timed':
+ sortf = None
+ elif mode=='urlfocus':
+ sortf = Sort('start', ascending=1)
+ else:
+ raise 'Invalid mode'
+
+ req=get_requests(files, start, end, statsfname, writestats, readstats)
+ analyze(req, top, sortf, start, end, mode, resolution, urlfocusurl,
+ urlfocustime)
+
+ except AssertionError, val:
+ a = "%s is not a valid %s sort spec, use one of %s"
+ print a % (val[0], val[1], val[2])
+ sys.exit(0)
+ except getopt.error, val:
+ print val
+ sys.exit(0)
+ except ProfileException, val:
+ print val
+ sys.exit(0)
+ except SystemExit:
+ sys.exit(0)
+ except:
+ import traceback
+ traceback.print_exc()
+ print usage()
+ sys.exit(0)
+
+if __name__ == '__main__':
+ main()
_______________________________________________
Zope-Checkins maillist - [email protected]
https://mail.zope.org/mailman/listinfo/zope-checkins