# -*- coding: utf-8 -*-
    from configparser import ConfigParser
    import psycopg2
    import logging
    import time
    from psycopg2._psycopg import InternalError
    #################################################
    configParser = ConfigParser()
    configFilePath = r'app_settings.conf'
    configParser.read(configFilePath)
    ##########################################
    # Config parser parameters
    database = configParser.get('db', 'database')
    host = configParser.get('db', 'host')
    user = configParser.get('db', 'user')
    password = configParser.get('db', 'password')
    sslmode = configParser.get('db', 'sslmode')
    # linking unified logging class and connected it to the database log writer (Db handler)
    import Logger
    logger = Logger.Logger.initLogging(
        "LogDB",
        "LogDB.log"
    )
    #Logging handler for PostgreSQL
    class psqlHandler(logging.Handler):
        initial_sql = """CREATE TABLE IF NOT EXISTS log(
                            Created text,
                            Name text,
                            LogLevel int,
                            LogLevelName text,
                            Message text,
                            Module text,
                            FuncName text,
                            LineNo int,
                            Exception text,
                            Process int,
                            Thread text,
                            ThreadName text
                       )"""

        insertion_sql = """INSERT INTO log(
                                created,
                                Name,
                                LogLevel,
                                LogLevelName,
                                Message,
                                Module,
                                FuncName,
                                LineNo,
                                Exception,
                                Process,
                                Thread,
                                ThreadName)
                                VALUES(
                                %(created)s,
                                %(name)s,
                                %(levelno)s,
                                %(levelname)s,
                                %(message)s,
                                %(module)s,
                                %(funcName)s,
                                %(lineno)s,
                                %(exc_text)s,
                                %(process)s,
                                %(thread)s,
                                %(threadName)s
                        );"""

        def connect(self):
            try:
                self.__connect = psycopg2.connect(
                    database=self.__database,
                    host = self.__host,
                    user = self.__user,
                    password = self.__password,
                    sslmode="disable")

                return True
            except:
                return False

        def __init__(self, params):

            if not params:
                raise Exception ("No database where to log ☻")

            self.__database = params['database']
            self.__host = params['host']
            self.__user = params['user']
            self.__password = params['password']

            self.__connect = None

            if not self.connect():
                raise Exception ("Database connection error, no logging ☻")

            logging.Handler.__init__(self)

            self.__connect.cursor().execute(psqlHandler.initial_sql)
            self.__connect.commit()
            self.__connect.cursor().close()

        def emit(self, record):

            # Use default formatting:
            self.format(record)

            if record.exc_info:
                #record.exc_text = logging.defaultFormatter.formatException(record.exc_info)
                record.exc_text = logging.Formatter('%(asctime)s | %(name)s | %(levelname)s | %(message)s')

            else:
                record.exc_text = ""

            # Insert log record:
            try:
                #cur =  self.__connect.cursor(cursor_factory=psycopg2.extras.DictCursor)
                cur = self.__connect.cursor()
            except:
                self.connect()
                cur = self.__connect.cursor()
            try:
                cur.execute(psqlHandler.insertion_sql, record.__dict__)
            except InternalError as ie:
                print(str(ie))

            self.__connect.commit()
            self.__connect.cursor().close()

    if __name__ == "__main__":

        myh = psqlHandler({''
                           'host':"localhost",
                           'user':"postgres",
                           'password':"secret",
                           'database':"postgres"})

        l = logging.getLogger("Snmp_Handler")
        l.setLevel(logging.DEBUG)
        l.addHandler(myh)
        l.info("Table was created...")