Mozilla BuildBot Trending/Snippets
Log File Parser
#!/usr/bin/env python
"""This is a log parser for Mozilla Testing Logs
Written by John Ford in 2009 and made available under MPL/GPL/LGPL"""
import re
from sys import argv
class Log:
"""I represent a Log. Currently, I only understand how to
parse lines of test output. I do not yet know about myself"""
lines = [] #All LogLine objects
def __init__(self, filename):
"""Create a Log object based on the file at a location"""
print "Log file: %s" % filename
try:
f = open(filename)
self.parseFile(f)
except IOError:
print "Log: encountered error while reading file"
finally:
f.close()
def parseFile(self, file):
"""I take a file object and parse all of its lines. Currently,
I understand most standard XPCShell tests, feed tests, and Reftests"""
rawlines = file.readlines()
for line in rawlines:
###############################
# Special case for feed tests #
###############################
if(re.match(r"PASS \| xml", line) or re.match(r"FAIL \| xml", line)):
try:
self.lines.append(FeedTestLogLine(line))
except InvalidLogLineError:
print "This line is not a feed test but shows up as such:\n%s" % line
#############################
# Special case for reftests #
#############################
elif(re.search(r"REFTEST", line)):
try:
self.lines.append(ReftestLogLine(line))
except InvalidLogLineError:
print "This line is not a reftest but shows up as such:\n%s" % line
###############################
# Standard test output format #
###############################
elif(re.search(r"PASS", line) or re.search(r"FAIL", line) or re.search(r"EXPECTED RANDOM", line)):
try:
self.lines.append(TestLogLine(line))
except InvalidLogLineError:
# TODO: figure out why this line isn't being executed ever
print "This line is not a standard test but shows up as such:\n%s" % line
################################################################
# Make sure that the start time is captured for the feed tests #
################################################################
# This is a bad way of doing this but is there until timestamps
# are added
elif(re.match(r"Start: ", line)):
time = line.replace("Start: ", "").strip()
for x in self.lines:
if(isinstance(x, FeedTestLogLine)):
x.startTime = time
def buildNumber(self):
"""I tell you which Build Number I am"""
return 1
def startTime(self):
"""I tell you when I started"""
return 1
def endTime(self):
"""I tell you when I finished"""
return 10
def factory(self):
"""I tell you which buildbot Factory I came from"""
return "f1"
def builder(self):
"""I tell you which buildbot Builder I came from"""
return "mozilla-buildbot"
def slave(self):
"""I tell you which buildbot BuildSlave I came from"""
return "local-osx"
def testCount(self):
"""I tell you how many test's output I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
count = count + 1
return count
def passCount(self):
"""I tell you how many test passes I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.passed()):
count = count + 1
return count
def failCount(self):
"""I tell you how many test fails I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.failed()):
count = count + 1
return count
def unexpectedCount(self):
"""I tell you how many unexpected test results I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.unexpected()):
count = count + 1
return count
def unexpectedPassCount(self):
"""I tell you how many unexpected passes I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.unexpectedPass()):
count = count + 1
return count
def unexpectedFailCount(self):
"""I tell you how many unexpected passes I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.unexpectedFail()):
count = count + 1
return count
def knownFailCount(self):
"""I tell you how many known fails I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.knownFail()):
count = count + 1
return count
def randomCount(self):
"""I tell you how many known fails I found"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.random()):
count = count + 1
return count
def badThingsCount(self):
"""I tell you how many BadThings happend"""
count = 0
for line in self.lines:
if isinstance(line, TestLogLine):
if(line.unexpected() or line.fail()):
count = count + 1
return count
def logURL(self):
"""I tell you where you can find me"""
return "http://www.example.com/waterfall"
def logLines(self):
"""If you want my LogLines, ask me here"""
return self.lines
class LogLine:
"""I represent a Log Line. I might be more than one
line of raw output from the log. I understand log output
in the format "X | msg" where X is a time and msg is
the rest of the output"""
startTime = None # Time command starts
msg = None # Message
def __init__(self, line):
chunks = line.split(" | ")
self.startTime = chunks[0].strip()
self.msg = chunks[1].strip()
def time(self):
"""I Tell you the time it took to make this line"""
return "%s minus %s" % startTime, endTime
#def startTime(self):
#"""I tell you the time this item was started"""
#return startTime
def endTime(self):
"""I tell you the time this line ended UNIMPLEMENTED"""
return None
class TestLogLine(LogLine):
"""I am a line of output specific to a Test run.
I understand logs in the format "X | Y | Z | Q"
Where X is a timestamp, Y is test status, Z is
a test name and Q is the test message"""
statusMsg = None # I store PASS, FAIL....
testName = None # I store the name of the test
def __init__(self, line):
"""Parse a line into a TestLogLine output"""
chunks = line.split(" | ")
try:
self.startTime = chunks[0].strip()
self.statusMsg = chunks[1].strip()
self.testName = chunks[2].strip()
self.msg = chunks[3].strip()
except IndexError:
raise InvalidLogLineError("This line does not use the standard log output format")
def passed(self):
"""I tell you if this line passed"""
return re.search("PASS", self.statusMsg) != None
def failed(self):
"""I tell you if this line failed"""
return re.search("FAIL", self.statusMsg) != None
def knownFail(self):
"""I tell you if this test was a known fail"""
return re.search("KNOWN-FAIL", self.statusMsg)
def unexpected(self):
"""I tell you if this was an unexpected result"""
return re.search("UNEXPECTED", self.statusMsg) != None
def unexpectedPass(self):
"""I tell you if this was an unexpected pass"""
return self.passed() and self.unexpected()
def unexpectedFail(self):
"""I tell you if this was an unexpected fail"""
return self.failed() and self.unexpected()
def random(self):
"""I tell you if this was expected random output"""
return re.search(r"\(EXPECTED RANDOM\)", self.statusMsg)
class FeedTestLogLine(TestLogLine):
"""I am a special case for the feed tests. I don't have
timestamps in my output yet, so the Log's parsefile method
adds the same timestamp to all of us. I understand log output
in the form: X | Y | Z | Q where X is test status,
Y and Z are the test name and Q is the test outcome"""
def __init__(self, line):
chunks = line.split(" | ")
try:
self.startTime = repr(0)
self.statusMsg = chunks[0].strip()
self.testName = "%s - %s" % (chunks[1].strip(), chunks[2].strip())
self.msg = chunks[3].strip()
except IndexError:
raise InvalidLogLineError("This line does not use the standard log output format")
class ReftestLogLine(TestLogLine):
"""I am a line of Reftest output. I do not yet have timing information
for each step and take a really long time to run so the suite's start time
is not valid for me. I understand things in the format X | Y | Z where
X is test status (with the word REFTEST removed), Y is the test's name and
Z is any special messages"""
def __init__(self, line):
chunks = line.split(" | ")
try:
self.startTime = repr(0)
self.statusMsg = chunks[0].replace("REFTEST ", "").strip()
self.testName = chunks[1].strip()
try:
self.msg = chunks[2].strip()
except IndexError:
self.msg = "No Message"
except IndexError:
raise InvalidLogLineError("This Reftest does not use the standard log output format")
class InvalidLogLineError(Exception):
"""I am an exception which is raised when someone makes an invalid LogLine"""
pass
if(__name__ == "__main__"):
log = Log(argv[1])
# This is desired output format from Bug443329
# BUILDID/BUILDTIME | TESTTIME | TESTNAME | MACHINE(from this we can map to OS) | STATUS | MSG | link to full log
for line in log.logLines():
if (isinstance(line, TestLogLine)):
print "%s/%s | %s | %s | %s | %s | %s | %s" % (
log.buildNumber(),
repr(log.startTime()),
line.startTime,
line.testName,
log.slave(),
line.statusMsg,
line.msg,
log.logURL())
print """Note:
Build ID, Build Time, Machine Name, Link to log are
all bogus fields"""
""" This code is what i tested with
for line in log.logLines():
if(isinstance(line, TestLogLine)):
print "=" * 100
print "Line start: %s" % line.startTime
print "Line status: %s" % line.statusMsg
print "Line name: %s" % line.testName
print "Line Msg: %s" % line.msg
print "Count: %d" % log.testCount()
print "Fails: %d" % log.failCount()
print "Known Fails: %d" % log.knownFailCount()
print "Passes: %d" % log.passCount()
print "Unexpected: %d" % log.unexpectedCount()
print "UnexpectedP: %d" % log.unexpectedPassCount()
print "UnexpectedF: %d" % log.unexpectedFailCount()
print "Random: %d" % log.randomCount()"""
Date Format Parser
This js code parses a terminal date string into a real date and time.
// This file is a parser for terminal "date" command
// format strings. Likely, you will want to use only
// timeParse(date, fmtstring)
// Copyright 2009 John Ford
// MPL-GPL-LGPL
/* This function pads a signle digit to a leading 0
as a string */
function pad(number){
if(number <= 9){
return "0" + "" + number;
} else {
return number;
}
}
/* Convert a specifer letter into a value based on date */
function specifier(date, letter){
switch(letter){
case 'Y':
return "" + (1900 + date.getYear());
case 'm':
//Whole numbering used for month
return pad(date.getMonth() + 1);
case 'd':
return pad(date.getDate());
case 'H':
return pad(date.getHours());
case 'M':
return pad(date.getMinutes());
case 'S':
return pad(date.getSeconds());
case 's':
return date.valueOf();
default:
return letter;
}
}
/* This will parse date format strings to give valid
output pased on POSIX date command when given a format
and a date object. Returns string */
function timeParse(date, fmt){
var output ="";
var input = "" + fmt;
input = input.replace(/\+/, "");
input = input.replace(/%*/g, "");
for each (letter in input){
if (letter == '%'){
continue;
} else {
output += specifier(date, "" + letter);
}
}
return output;
}