NFVBENCH-153 Add support for python3

[nfvbench.git] / nfvbench / fluentd.py

diff --git a/nfvbench/fluentd.py b/nfvbench/fluentd.py
index a9bda62..535d640 100644 (file)
--- a/nfvbench/fluentd.py
+++ b/nfvbench/fluentd.py
@@ -12,9 +12,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import logging
+
 from datetime import datetime
 from fluent import sender
-import logging
 import pytz
 
 
@@ -27,24 +28,34 @@ class FluentLogHandler(logging.Handler):
     - the level name
     - the runlogdate (to tie multiple run-related logs together)
     The timestamp is retrieved by the fluentd library.
+    There will be only one instance of FluentLogHandler running.
     '''
 
-    def __init__(self, tag, fluentd_ip='127.0.0.1', fluentd_port=24224):
+    def __init__(self, fluentd_configs):
         logging.Handler.__init__(self)
-        self.tag = tag
+        self.log_senders = []
+        self.result_senders = []
+        self.runlogdate = "1970-01-01T00:00:00.000000+0000"
         self.formatter = logging.Formatter('%(message)s')
-        self.sender = sender.FluentSender(self.tag, host=fluentd_ip, port=fluentd_port)
-        self.runlogdate = 0
+        for fluentd_config in fluentd_configs:
+            if fluentd_config.logging_tag:
+                self.log_senders.append(
+                    sender.FluentSender(fluentd_config.logging_tag, host=fluentd_config.ip,
+                                        port=fluentd_config.port))
+            if fluentd_config.result_tag:
+                self.result_senders.append(
+                    sender.FluentSender(fluentd_config.result_tag, host=fluentd_config.ip,
+                                        port=fluentd_config.port))
         self.__warning_counter = 0
         self.__error_counter = 0
 
     def start_new_run(self):
         '''Delimitate a new run in the stream of records with a new timestamp
         '''
-        self.runlogdate = self.__get_timestamp()
         # reset counters
         self.__warning_counter = 0
         self.__error_counter = 0
+        self.runlogdate = self.__get_timestamp()
         # send start record
         self.__send_start_record()
 
@@ -54,18 +65,21 @@ class FluentLogHandler(logging.Handler):
             "message": self.formatter.format(record),
             "@timestamp": self.__get_timestamp()
         }
-        # if runlogdate is 0, it's a log from server (not an nfvbench run) so do not send runlogdate
-        if self.runlogdate != 0:
+        # if runlogdate is Jan 1st 1970, it's a log from server (not an nfvbench run)
+        # so do not send runlogdate
+        if self.runlogdate != "1970-01-01T00:00:00.000000+0000":
             data["runlogdate"] = self.runlogdate
 
         self.__update_stats(record.levelno)
-        self.sender.emit(None, data)
+        for log_sender in self.log_senders:
+            log_sender.emit(None, data)
 
-    # this function is called by summarizer
+    # this function is called by summarizer, and used for sending results
     def record_send(self, record):
-        self.sender.emit(None, record)
+        for result_sender in self.result_senders:
+            result_sender.emit(None, record)
 
-    # send START record for each run
+    # send START log record for each run
     def __send_start_record(self):
         data = {
             "runlogdate": self.runlogdate,
@@ -76,7 +90,8 @@ class FluentLogHandler(logging.Handler):
             "numwarnings": 0,
             "@timestamp": self.__get_timestamp()
         }
-        self.sender.emit(None, data)
+        for log_sender in self.log_senders:
+            log_sender.emit(None, data)
 
     # send stats related to the current run and reset state for a new run
     def send_run_summary(self, run_summary_required):
@@ -89,16 +104,17 @@ class FluentLogHandler(logging.Handler):
                 "numwarnings": self.__warning_counter,
                 "@timestamp": self.__get_timestamp()
             }
-            # if runlogdate is 0, it's a log from server (not an nfvbench run)
+            # if runlogdate is Jan 1st 1970, it's a log from server (not an nfvbench run)
             # so don't send runlogdate
-            if self.runlogdate != 0:
+            if self.runlogdate != "1970-01-01T00:00:00.000000+0000":
                 data["runlogdate"] = self.runlogdate
-            self.sender.emit(None, data)
+            for log_sender in self.log_senders:
+                log_sender.emit(None, data)
 
     def __get_highest_level(self):
         if self.__error_counter > 0:
             return logging.ERROR
-        elif self.__warning_counter > 0:
+        if self.__warning_counter > 0:
             return logging.WARNING
         return logging.INFO
 
@@ -106,10 +122,9 @@ class FluentLogHandler(logging.Handler):
         highest_level = self.__get_highest_level()
         if highest_level == logging.INFO:
             return "GOOD RUN"
-        elif highest_level == logging.WARNING:
+        if highest_level == logging.WARNING:
             return "RUN WITH WARNINGS"
-        else:
-            return "RUN WITH ERRORS"
+        return "RUN WITH ERRORS"
 
     def __update_stats(self, levelno):
         if levelno == logging.WARNING: