Ejemplo n.º 1
0
 def testWillMarkforSpecifiedTimeandNotAfterwards(self):
     level = 'FATAL'
     trace = "FATAL there could be an error in the application"
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     message = Message(logcolors)
     notifier = notifications.CornerMark(0.01)
     anylog = Log('out.log')
     message.parse(trace, anylog)
     termcols = os.popen("tput cols")
     ttcols = termcols.readline()
     termcols.close()
     ttcols = int(ttcols)
     padding = ttcols - len(notifier.MARK)
     output = padding * " " + termcolors.backgroundemph + notifier.MARK +\
             termcolors.reset
     notifier.notify(message, anylog)
     self.assertEqual(output, sys.stdout.captured[0])
     trace = "INFO this is an info trace"
     sys.stdout.flush()
     time.sleep(0.02)
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     self.assertFalse(sys.stdout.captured)
Ejemplo n.º 2
0
 def testMarkedTARGETOverMarkableLevel(self):
     configfile = CONFIG
     logfile = "/any/path/out.log"
     trace = "this is a FATAL targeted log trace"
     fh = open(configfile, 'w')
     fh.write("targets "+logfile+"=targeted\n")
     fh.close()
     properties = Property(configfile)
     properties.parse_properties()
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     notifier = notifications.CornerMark(0.02)
     anylog = Log(logfile, properties)
     message = Message(logcolors, properties = properties)
     termcols = os.popen("tput cols")
     ttcols = termcols.readline()
     termcols.close()
     ttcols = int(ttcols)
     padding = ttcols - len(notifier.MARK)
     output = padding * " " + termcolors.oncyanemph + notifier.MARK +\
             termcolors.reset
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     self.assertEqual(output, sys.stdout.captured[0])
Ejemplo n.º 3
0
 def testReportToAFile(self):
     reportfileFullPath = "reportfile.txt"
     fh = open('aconfig','w')
     fh.write('analyticsnotification = '+ reportfileFullPath +'\n')
     fh.write('analyticsgaptime = 0.1\n')
     fh.close()
     properties = Property('aconfig')
     properties.parse_properties()
     self.assertTrue(properties.is_key('analyticsnotification'))
     log = Log('out.log')
     arrayLog = [log]
     resume = reporting.Resume(arrayLog)
     resume.setAnalyticsGapNotification(0.1)
     resume.notification_type(reportfileFullPath)
     fh = open('out.log')
     lines = fh.readlines()
     fh.close()
     logcolors = LogColors()
     msg = Message(logcolors)
     time.sleep(0.1)
     for line in lines:
         msg.parse(line, log)
         resume.update(msg, log)
     fh = open(reportfileFullPath)
     reportlength = len(fh.readlines())
     fh.close()
     os.remove(reportfileFullPath)
     self.assertEquals(22, reportlength)
     os.remove('aconfig')
Ejemplo n.º 4
0
 def testShouldExecuteIfTargetMessage(self):
     logcolor = LogColors()
     logfile = 'anylog'
     log = Log(logfile)
     fh = open(CONFIG, 'w')
     fh.write("executor = echo ' %s %s '\n")
     fh.close()
     trace = "this is an info log trace"
     trigger = ['echo', trace, logfile]
     properties = Property(CONFIG)
     properties.parse_properties()
     message = Message(logcolor, target = 'trace')
     executor_mock = self.mocker.mock()
     executor_mock._build_trigger(trace, logfile)
     self.mocker.result(trigger)
     executor_mock.started
     self.mocker.result(True)
     landing_mock = self.mocker.mock()
     landing_mock.landing(trigger)
     self.mocker.result(True)
     executor_mock.trigger_executor
     self.mocker.result(landing_mock)
     self.mocker.replay()
     message.parse(trace, log)
     self.assertTrue(message.isATarget())
     notifications.Executor.notify.im_func(executor_mock, message, log)
Ejemplo n.º 5
0
 def pipeOut(self):
     """Reads from standard input 
     and prints to standard output"""
     message = Message(self.logcolors, self.loglevels, self.target, self.properties)
     stdin = sys.stdin
     anylog = Log('anylog')
     for line in stdin:
         message.parse(line, anylog)
         for action in self.actions:
             action.notify(message, anylog)
Ejemplo n.º 6
0
 def testnoNotification(self):
     pattern = re.compile(r'hi, this line to be notified')
     trace = "info this is just a log trace"
     notifier = notifications.Filter(pattern)
     sys.stdout = Writer()
     logcolors = LogColors()
     message = Message(logcolors)
     anylog = Log('out.log')
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     # assert is empty
     self.assertFalse(sys.stdout.captured)
Ejemplo n.º 7
0
 def testshouldNotColorizeifLevelKeyInaWord(self):
     # Testing boundary regex as for suggestion of 
     # Carlo Bertoldi
     trace = "this is a logtrace where someinfoword could be found"
     sys.stdout = Writer()
     logcolors = LogColors()
     message = Message(logcolors)
     notifier = notifications.Print()
     anylog = Log('out.log')
     message.parse(trace, anylog)
     notifier.notify(message,anylog)
     self.assertEqual(trace, sys.stdout.captured[0])
     self.assertEqual('', message.messageLevel)        
Ejemplo n.º 8
0
 def testshouldFailColorizeWithBackground(self):
     trace = "FATAL there could be an error in the application"
     level = 'WARN'
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     logcolors.parse_config(PropertiesBackGround())
     message = Message(logcolors)
     notifier = notifications.Print()
     anylog = Log('out.log')
     message.parse(trace, anylog)
     output = logcolors.getLevelColor(level)+trace+termcolors.reset
     notifier.notify(message,anylog)
     self.assertNotEqual(output, sys.stdout.captured[0])
Ejemplo n.º 9
0
 def testShouldColorizeWarningLevelAsWell(self):
     '''test that *warning* keyword gets colorized as well'''
     level = 'WARNING'
     trace = "WARNING there could be an error in the application"
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     message = Message(logcolors)
     notifier = notifications.Print()
     anylog = Log('out.log')
     message.parse(trace, anylog)
     output = logcolors.getLevelColor(level)+trace+termcolors.reset
     notifier.notify(message,anylog)
     self.assertEqual(output, sys.stdout.captured[0])
Ejemplo n.º 10
0
 def testnotify(self):
     pattern = re.compile(r'hi, this line to be notified')
     trace = "info hi, this line to be notified"
     level = "INFO"
     notifier = notifications.Filter(pattern)
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     message = Message(logcolors)
     anylog = Log('out.log')
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     output = logcolors.getLevelColor(level)+trace+termcolors.reset
     self.assertEqual(output, sys.stdout.captured[0])
Ejemplo n.º 11
0
 def testshouldColorizefirstLevelFoundignoringSecondinSameTrace(self):
     # Test for fix 5
     # Should give priority to FATAL in next trace
     level = 'FATAL'
     trace = "FATAL there could be an error in the application"
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     message = Message(logcolors)
     notifier = notifications.Print()
     anylog = Log('out.log')
     message.parse(trace, anylog)
     output = logcolors.getLevelColor(level)+trace+termcolors.reset
     notifier.notify(message,anylog)
     self.assertEqual(output, sys.stdout.captured[0])
Ejemplo n.º 12
0
 def testShouldContinueIfExecutorFails(self):
     logcolor = LogColors()
     message = Message(logcolor)
     log = Log('anylog')
     fh = open(CONFIG, 'w')
     fh.write('executor = anycommand\n')
     fh.close()
     trace = "this is a critical log trace"
     properties = Property(CONFIG)
     properties.parse_properties()
     executor = notifications.Executor(properties)
     message.parse(trace, log)
     executor.notify(message, log)
     time.sleep(0.0002)
     executor.stop()
Ejemplo n.º 13
0
 def testShouldNotExecuteIfLevelNotInPullers(self):
     logcolor = LogColors()
     message = Message(logcolor)
     log = Log('anylog')
     fh = open(CONFIG, 'w')
     fh.write('executor = anything %s %s\n')
     fh.close()
     trace = "this is an info log trace"
     properties = Property(CONFIG)
     properties.parse_properties()
     executor = notifications.Executor(properties)
     message.parse(trace, log)
     executor.notify(message, log)
     time.sleep(0.0002)
     executor.stop()
     self.assertFalse(sys.stdout.captured)
Ejemplo n.º 14
0
 def testShouldNotifyWithNoFullTrigger(self):
     logcolor = LogColors()
     message = Message(logcolor)
     log = Log('anylog')
     logpath = log.path
     fh = open(CONFIG, 'w')
     fh.write('executor = echo\n')
     fh.close()
     trace = "this is a fatal log trace"
     properties = Property(CONFIG)
     properties.parse_properties()
     executor = notifications.Executor(properties)
     message.parse(trace, log)
     trigger = executor._build_trigger(trace, logpath)
     self.assertEqual(['echo'], trigger)
     executor.notify(message, log)
     executor.stop()
Ejemplo n.º 15
0
 def tailer(self):
     """Stdout multicolor tailer"""
     message = Message(self.logcolors, self.loglevels, self.target, self.properties)
     anylog = Log("anylog")
     for hostname in self.hostnames.keys():
         command = self.hostnames[hostname]["command"]
         self.logger.debug("command [%s] to be executed in host [%s]" % (command, hostname))
         self.hostnameChannels[hostname]["channel"].exec_command(command)
     try:
         lasthostnameChanged = ""
         while True:
             for hostname in self.hostnames.keys():
                 sshChannel = self.hostnameChannels[hostname]["channel"]
                 rr, _, _ = select.select([sshChannel], [], [], 0.0)
                 if len(rr) > 0:
                     lines = sshChannel.recv(4096).split("\n")
                     if hostname != lasthostnameChanged:
                         self.__hostnameChangedHeader(hostname)
                     for line in lines:
                         message.parse(line, anylog)
                         self.actions.notify(message, anylog)
                     lasthostnameChanged = hostname
             time.sleep(1)
     except:
         print "\nfinishing ..."
         for hostname in self.hostnames.keys():
             sshChannel = self.hostnameChannels[hostname]["channel"]
             sshclient = self.hostnameChannels[hostname]["client"]
             command = self.hostnames[hostname]["command"]
             procidCommand = "pgrep -f -x " + '"' + command + '"'
             self.logger.debug("procid command [%s]" % procidCommand)
             sshChannel.close()
             stdin, stdout, stderr = sshclient.exec_command(procidCommand)
             res = stdout.readlines()
             if res:
                 procid = res[0].rstrip()
                 self.logger.debug("procid [%s]" % procid)
                 # is process still alive after closing channel?
                 if procid:
                     # kill it
                     killprocid = "kill -9 " + procid
                     stdin, stdout, stderr = sshclient.exec_command(killprocid)
             # sshChannel.shutdown(2)
             sshclient.close()
         print "Ended log4tailer, because colors are fun"
         sys.exit()
Ejemplo n.º 16
0
 def testShouldContinueTailingIfExecutableTakesLongTime(self):
     logcolor = LogColors()
     message = Message(logcolor)
     log = Log('anylog')
     fh = open(CONFIG, 'w')
     fh.write('executor = ' + EXECUTABLE +'\n')
     fh.close()
     trace = "this is an error log trace"
     properties = Property(CONFIG)
     properties.parse_properties()
     executor = notifications.Executor(properties)
     message.parse(trace, log)
     start = time.time()
     executor.notify(message, log)
     finished = time.time()
     ellapsed = start - finished
     time.sleep(0.0002)
     executor.stop()
     # executable.py sleeps for three seconds
     self.assertTrue(ellapsed < 0.1)
Ejemplo n.º 17
0
 def testMarkedFATALMarkedWARNING(self):
     termcols = os.popen("tput cols")
     ttcols = termcols.readline()
     termcols.close()
     trace = "FATAL this is a fatal trace"
     sys.stdout = Writer()
     logcolors = LogColors()
     termcolors = TermColorCodes()
     message = Message(logcolors)
     notifier = notifications.CornerMark(0.02)
     anylog = Log('out.log')
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     ttcols = int(ttcols)
     padding = ttcols - len(notifier.MARK)
     output = padding * " " + termcolors.onyellowemph + notifier.MARK +\
             termcolors.reset
     trace = "WARN this is just a warn"
     message.parse(trace, anylog)
     notifier.notify(message, anylog)
     self.assertEquals(output, sys.stdout.captured[2])
Ejemplo n.º 18
0
 def testShouldNotifyWithFullTrigger(self):
     logcolor = LogColors()
     message = Message(logcolor)
     log = Log('anylog')
     fh = open(CONFIG, 'w')
     fh.write('executor = ls -l %s %s\n')
     fh.close()
     trace = "this is a FATAL log trace"
     trigger = ['ls', '-l', trace, log.path ]
     properties = Property(CONFIG)
     properties.parse_properties()
     os_mock = self.mocker.replace('subprocess')
     os_mock.call(' '.join(trigger), shell = True)
     self.mocker.result(True)
     self.mocker.replay()
     # we just verify the trigger gets 
     # called in the tearDown
     executor = notifications.Executor(properties)
     message.parse(trace, log)
     executor.notify(message, log)
     time.sleep(0.0002)
     executor.stop()
Ejemplo n.º 19
0
 def test_shouldPost_if_alertable(self):
     properties = self.mocker.mock()
     properties.get_value('server_url')
     self.mocker.result('localhost')
     properties.get_value('server_port')
     self.mocker.result(8000)
     properties.get_value('server_service_uri')
     self.mocker.result('/')
     properties.get_value('server_service_register_uri')
     self.mocker.result('/register')
     properties.get_value('server_service_unregister_uri')
     self.mocker.result('/unregister')
     logcolors = LogColors()
     logtrace = 'this is an error log trace'
     log = Log('anylog')
     message = Message(logcolors)
     message.parse(logtrace, log)
     self.mocker.replay()
     poster = notifications.Poster(properties)
     require_server()
     response = poster.notify(message, log)
     self.assertEqual(response.status, 200)
Ejemplo n.º 20
0
 def test_not_execute_if_not_alertable_Level(self):
     properties = self.mocker.mock()
     properties.get_value('server_url')
     self.mocker.result('localhost')
     properties.get_value('server_port')
     self.mocker.result(8000)
     properties.get_value('server_service_uri')
     self.mocker.result('/')
     properties.get_value('server_service_register_uri')
     self.mocker.result('/register')
     properties.get_value('server_service_unregister_uri')
     self.mocker.result('/unregister')
     logcolors = LogColors()
     logtrace = 'this is an info log trace'
     log = Log('anylog')
     message = Message(logcolors, target = 'anything')
     message.parse(logtrace, log)
     self.mocker.replay()
     poster = notifications.Poster(properties)
     poster.registered_logs[log] = True
     response = poster.notify(message, log)
     self.assertFalse(response)
Ejemplo n.º 21
0
 def test_printandshoot(self):
     sys.stdout = Writer()
     log_traces = ['this is an info log trace', 
             'this is a fatal log trace']
     log = Log('anylog')
     logcolors = LogColors()
     output = 'picture.png'
     propertiesmock = self.mocker.mock()
     propertiesmock.get_value('screenshot')
     self.mocker.result(output)
     self.mocker.replay()
     printandshoot = notifications.PrintShot(propertiesmock)
     message = Message(logcolors)
     for trace in log_traces:
         message.parse(trace, log)
         printandshoot.notify(message, log)
     found = False
     for msg in sys.stdout.captured:
         if msg.find(log_traces[1]) >= 0:
             found = True
     if not found:
         self.fail()
     self.assertTrue(os.path.exists(self.output))
Ejemplo n.º 22
0
 def testMessage(self):
     logcolors = LogColors() #using default colors
     termcolors = TermColorCodes()
     target = None
     notifier = notifications.Print()
     message = Message(logcolors,target)
     log = Log(self.logfile)
     log.openLog()
     sys.stdout = Writer()
     #testing Colors with default pauseModes
     for count in range(len(self.someLogTraces)):
         line = log.readLine()
         line = line.rstrip()
         level = line.split('>')
         message.parse(line, log)
         output = logcolors.getLevelColor(level[0])+line+termcolors.reset
         notifier.notify(message,log)
         self.assertTrue(output in sys.stdout.captured)
     
     line = log.readLine()
     self.assertEqual('',line)
     message.parse(line, log)
     self.assertFalse(notifier.notify(message,log))
Ejemplo n.º 23
0
 def printLastNLines(self,n):
     '''tail -n numberoflines method in pager mode'''
     message = Message(self.logcolors, self.loglevels)
     action = notifications.Print()
     for log in self.arrayLog:
         fd = log.openLog()
         numlines = log.numLines()
         pos = numlines-n
         count = 0
         buff = []
         ttlines = get_term_lines()
         for curpos,line in enumerate(fd):
             if curpos >= pos:
                 line = line.rstrip()
                 message.parse(line, log)
                 action.notify(message, log)
                 count += 1
                 buff.append(line)
                 if (count % ttlines) == 0:
                     raw_input("continue\n")
                     count = 0
                     ttlines = get_term_lines()
         log.closeLog()
Ejemplo n.º 24
0
 def testshouldColorizeMultilineLogTraces(self):
     trace = 'FATAL> something went wrong\nin here as well'
     trace0, trace1 = trace.split('\n')
     level = 'FATAL'
     termcolors = TermColorCodes()
     # now assert trace0 and trace1 are in FATAL level
     sys.stdout = Writer()
     logcolors = LogColors()
     message = Message(logcolors)
     notifier = notifications.Print()
     anylog = Log('out.log')
     expectedLogTrace0 = logcolors.getLevelColor(level) + \
             trace0 + termcolors.reset
     expectedLogTrace1 = logcolors.getLevelColor(level) + \
             trace1 + termcolors.reset
     message.parse(trace0, anylog)
     notifier.notify(message, anylog)
     self.assertEqual(expectedLogTrace0, sys.stdout.captured[0])
     self.assertEqual('FATAL', message.messageLevel)        
     message.parse(trace1, anylog)
     notifier.notify(message, anylog)
     self.assertEqual(expectedLogTrace1, sys.stdout.captured[2])
     self.assertEqual('FATAL', message.messageLevel)        
Ejemplo n.º 25
0
 def testShouldReportaLogOwnTarget(self):
     logfile = "/any/path/outtarget.log"
     configfile = "aconfig.txt"
     logcolors = LogColors()
     fh = open(configfile, 'w')
     fh.write("targets "+logfile+" = should\n")
     fh.close()
     properties = Property(configfile)
     properties.parse_properties()
     mylog = Log(logfile, properties)
     optional_params = (None, True, logfile)
     self.assertEqual(optional_params, (mylog.ownOutputColor,
         mylog.patTarget, mylog.path))
     arraylogs = [mylog]
     resume = reporting.Resume(arraylogs)
     message = Message(logcolors, properties = properties)
     logtrace = "log trace info target should be reported"
     message.parse(logtrace, mylog)
     resume.update(message, mylog)
     outLogReport = resume.logsReport[mylog.path]
     numofTargets = 1
     gotnumTargets = outLogReport['TARGET']
     self.assertEquals(numofTargets, gotnumTargets)
Ejemplo n.º 26
0
 def tailer(self):
     '''Stdout multicolor tailer'''
     message = Message(self.logcolors,self.loglevels, self.target,self.properties)
     resume = self.resumeBuilder()
     self.posEnd()
     get_log_lines = "readLines"
     if self.throttleTime:
         get_log_lines = "readLine"
     if self.silence:
         daemonize()
     try:
         self.__initialize(message)
         lastLogPathChanged = ""
         curpath = ""
         while True:
             found = 0
             time.sleep(self.throttleTime)
             for log in self.arrayLog:
                 curpath = log.path
                 if hasRotated(log):
                     found = 0
                 lines = getattr(log, get_log_lines)()
                 if not lines:
                     # notify actions
                     message.parse('', log)
                     resume.update(message, log)
                     self.notifyActions(message, log)
                     continue
                 if isinstance(lines, str):
                     lines = [lines]
                 for line in lines:
                     found = 1
                     line = line.rstrip()
                     # to emulate the tail command
                     if curpath != lastLogPathChanged:
                         print
                         _printHeaderLog(log.path)
                     lastLogPathChanged = log.path
                     message.parse(line, log)
                     resume.update(message, log)
                     self.notifyActions(message, log)
                 log.size = log.getcurrSize()
             if found == 0:
                 #sleep for 1 sec
                 time.sleep(self.pause)
     except (KeyboardInterrupt, OSError, IOError):
         for log in self.arrayLog:
             log.closeLog()
         if self.mailAction:
             self.mailAction.quitSMTP()
         for action in self.actions:
             # executor notification
             if hasattr(action, 'stop'):
                 action.stop()
             # post notification
             if hasattr(action, 'unregister'):
                 for log in self.arrayLog:
                     action.unregister(log)
         print "\n"
         resume.report()
         print "Ended log4tailer, because colors are fun"