Created logger for the application + basic logs

packages/flare/python/cron_job_ingest_events.py

@@ -8,6 +8,7 @@
 import vendor.splunklib.client as client
 
 from flare import FlareAPI
+from logger import Logger
 
 APP_NAME = "flare"
 HOST = "localhost"
@@ -20,6 +21,7 @@
 def main():
     # Cron job are stacking, so you have to make sure to stop the current one before the next one starts
     cron_job_start_timestamp = datetime.now().timestamp()
+    logger = Logger(class_name=__file__)
     try:
         splunk_service = client.connect(
             host=HOST,
@@ -54,19 +56,23 @@ def main():
     start_date = get_start_date_value(app=app)
     while True:
         event_feed = flare_api.retrieve_feed(from_=from_, start_date=start_date)
-        save_values(app=app, tenant_id=tenant_id, next=event_feed["next"])
+        next_value = event_feed["next"]
+        save_values(app=app, tenant_id=tenant_id, next=next_value)
 
         if event_feed["items"]:
             for item in event_feed["items"]:
                 print(json.dumps(item))
 
+        seconds_since_cron_start = int(datetime.now().timestamp() - cron_job_start_timestamp)
+        logger.debug("Next:{}, Seconds since start:{}".format(next_value, seconds_since_cron_start))
         if (
-            int(datetime.now().timestamp() - cron_job_start_timestamp)
+            seconds_since_cron_start
             >= CRON_JOB_MAX_RUNNING_SECONDS
         ):
+            logger.debug("Cron job reached timeout of {} seconds, killing it.".format(CRON_JOB_MAX_RUNNING_SECONDS))
             break
-        if event_feed["next"]:
-            from_ = event_feed["next"]
+        if next_value:
+            from_ = next_value
         else:
             break
 

packages/flare/python/flare_external_requests.py

@@ -4,8 +4,10 @@
 import json
 from typing import Any
 
+sys.path.insert(0, os.path.dirname(__file__))
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "vendor"))
 from flareio import FlareApiClient
+from logger import Logger
 
 
 def parseParams(payload: str) -> dict[str, Any]:
@@ -18,9 +20,12 @@ def parseParams(payload: str) -> dict[str, Any]:
 
 class FlareUserTenants(splunk.rest.BaseRestHandler):
     def handle_POST(self):
+        logger = Logger(class_name=__file__)
         payload = self.request["payload"]
         params = parseParams(payload)
         self.flare_client = FlareApiClient(api_key=params["apiKey"])
         user_tenants_response = self.flare_client.get("firework/v2/me/tenants")
         self.response.setHeader("Content-Type", "application/json")
-        self.response.write(json.dumps(user_tenants_response.json()))
+        tenants_response = user_tenants_response.json()
+        logger.debug(tenants_response)
+        self.response.write(json.dumps(tenants_response))

packages/flare/python/logger.py

@@ -0,0 +1,37 @@
+import logging
+import os
+from typing import Any
+
+from logging.handlers import TimedRotatingFileHandler
+
+class Logger():
+    def __init__(self, *, class_name: str) -> None:
+        SPLUNK_HOME = os.environ.get("SPLUNK_HOME")
+        if not SPLUNK_HOME:
+            raise Exception("SPLUNK_HOME isn't defined, can't create logger")
+        LOG_FILENAME = os.path.join(SPLUNK_HOME,"var","log","splunk","flare.log")
+        self.tag_name = os.path.splitext(os.path.basename(class_name))[0]
+        self._logger = logging.getLogger("flare-{}".format(self.tag_name))
+        self._logger.setLevel(logging.DEBUG)
+        formatter = logging.Formatter('%(asctime)s %(levelname)-5s %(message)s')
+        handler = TimedRotatingFileHandler(LOG_FILENAME, when="d",interval=1,backupCount=5)
+        handler.setFormatter(formatter)
+        self._logger.addHandler(handler)
+
+    def debug(self, msg: Any):
+        self._logger.debug(msg="{}: {}".format(self.tag_name, msg))
+
+    def info(self, msg: Any):
+        self._logger.info(msg="{}: {}".format(self.tag_name, msg))
+
+    def warning(self, msg: Any):
+        self._logger.warning(msg="{}: {}".format(self.tag_name, msg))
+
+    def error(self, msg: Any):
+        self._logger.error(msg="{}: {}".format(self.tag_name, msg))
+
+    def exception(self, msg: Any):
+        self._logger.exception(msg="{}: {}".format(self.tag_name, msg))
+
+    def critical(self, msg: Any):
+        self._logger.critical(msg="{}: {}".format(self.tag_name, msg))