sqldb-logging 0.1.1__tar.gz

sqldb_logging-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ihar Shurupau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqldb_logging-0.1.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: sqldb-logging
+Version: 0.1.1
+Summary: An extension to the Python logging library that allows logging to SQL databases using SQLAlchemy
+Author-email: Ihar Shurupau <ihar.shurupau@gmail.com>
+Maintainer-email: Ihar Shurupau <ihar.shurupau@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/shurihar/sqldb-logging
+Project-URL: Issues, https://github.com/shurihar/sqldb-logging/issues
+Keywords: logging,log,logger,sql,sqldb,sqlalchemy,database,db
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=2.0.46
+Provides-Extra: databricks
+Requires-Dist: databricks-sqlalchemy>=2.0.8; extra == "databricks"
+Dynamic: license-file
+
+# sqldb-logging
+An extension to the Python logging library that allows logging to SQL databases using [SQLAlchemy](https://www.sqlalchemy.org/)
+
+## Requirements
+- Python version 3.11 or later
+
+## Installation
+
+Basic installation:
+
+```shell
+pip install sqldb-logging
+```
+
+Installation with optional dependencies:
+
+```shell
+pip install sqldb-logging[databricks]
+```
+
+## Usage
+
+```python
+import logging
+
+from sqldb_logging.handlers import SQLHandler
+
+handler = SQLHandler(
+    table='log_table',
+    drivername='postgresql+psycopg',
+    username='postgres',
+    password='postgres',
+    host='localhost',
+    port=5432,
+    database='postgres',
+    schema='public'
+)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(handler)
+logger.info('Doing something')
+```
+**Note**: The database user must have CREATE TABLE permission to create a log table if it doesn't exist.
+If the log table already exists,
+its schema must reflect the structure of [LogRecord](https://docs.python.org/3/library/logging.html#logrecord-objects)
+
+## Supported databases
+In theory, any database supported by SQLAlchemy should work. The following databases have been confirmed to work:
+- MySQL
+- PostgreSQL
+- SQLite
+- Databricks
+

sqldb_logging-0.1.1/README.md

@@ -0,0 +1,54 @@
+# sqldb-logging
+An extension to the Python logging library that allows logging to SQL databases using [SQLAlchemy](https://www.sqlalchemy.org/)
+
+## Requirements
+- Python version 3.11 or later
+
+## Installation
+
+Basic installation:
+
+```shell
+pip install sqldb-logging
+```
+
+Installation with optional dependencies:
+
+```shell
+pip install sqldb-logging[databricks]
+```
+
+## Usage
+
+```python
+import logging
+
+from sqldb_logging.handlers import SQLHandler
+
+handler = SQLHandler(
+    table='log_table',
+    drivername='postgresql+psycopg',
+    username='postgres',
+    password='postgres',
+    host='localhost',
+    port=5432,
+    database='postgres',
+    schema='public'
+)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(handler)
+logger.info('Doing something')
+```
+**Note**: The database user must have CREATE TABLE permission to create a log table if it doesn't exist.
+If the log table already exists,
+its schema must reflect the structure of [LogRecord](https://docs.python.org/3/library/logging.html#logrecord-objects)
+
+## Supported databases
+In theory, any database supported by SQLAlchemy should work. The following databases have been confirmed to work:
+- MySQL
+- PostgreSQL
+- SQLite
+- Databricks
+

sqldb_logging-0.1.1/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqldb-logging"
+version = "0.1.1"
+dependencies = [
+    "SQLAlchemy>=2.0.46",
+]
+requires-python = ">=3.11"
+authors = [
+    { name="Ihar Shurupau", email="ihar.shurupau@gmail.com" },
+]
+maintainers = [
+    { name="Ihar Shurupau", email="ihar.shurupau@gmail.com" },
+]
+description = "An extension to the Python logging library that allows logging to SQL databases using SQLAlchemy"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+keywords = ["logging", "log", "logger", "sql", "sqldb", "sqlalchemy", "database", "db"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Database",
+    "Topic :: System :: Logging",
+]
+
+[project.optional-dependencies]
+databricks = ["databricks-sqlalchemy>=2.0.8"]
+
+[project.urls]
+Repository = "https://github.com/shurihar/sqldb-logging"
+Issues = "https://github.com/shurihar/sqldb-logging/issues"

sqldb_logging-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqldb_logging-0.1.1/src/sqldb_logging/handlers.py

@@ -0,0 +1,158 @@
+import logging
+import traceback
+from datetime import datetime
+from decimal import Decimal
+from logging.handlers import MemoryHandler
+from typing import Any
+
+from sqlalchemy import (
+    URL,
+    create_engine,
+    MetaData,
+    Table,
+    Column,
+    DateTime,
+    Numeric,
+    Text,
+    SmallInteger,
+    Integer,
+    BigInteger,
+    insert
+)
+
+
+class SQLHandler(MemoryHandler):
+    """
+    A handler class which buffers logging records in memory, periodically
+    flushing them to a database table using SQLAlchemy. Flushing occurs whenever the buffer
+    is full, or when an event of a certain severity or greater is seen.
+    :param table: The name of the database table where to write logs.
+    :param drivername: the name of the database backend. This name will
+        correspond to a module in sqlalchemy/databases or a third party
+        plug-in.
+    :param username: The user name.
+    :param password: database password.  Is typically a string, but may
+        also be an object that can be stringified with ``str()``.
+    :param host: The name of the host.
+    :param port: The port number.
+    :param database: The database name.
+    :param schema: The schema name for the log table, which is required if
+        the table resides in a schema other than the default selected schema
+        for the engine's database connection.  Defaults to ``None``.
+    :param buffer_size: The number of records to buffer in memory before flushing to the database.
+        The default is 1, which means that each record is flushed immediately.
+        Setting this parameter to a higher value reduces the number of round trips to the database, but requires
+        calling flush() or close() method before exiting the program to flush all pending records to the database.
+        It may also result in the loss of buffered records if the program terminates unexpectedly.
+        Using the with statement when instantiating the handler can help avoid this problem.
+    :param flush_level: the level at which flushing should occur.
+    :param kwargs: takes a wide variety of options which are routed towards their appropriate components.
+        For more information, see https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine
+    """
+
+    def __init__(
+            self,
+            table: str,
+            drivername: str,
+            username: str | None = None,
+            password: str | None = None,
+            host: str | None = None,
+            port: int | None = None,
+            database: str | None = None,
+            schema: str | None = None,
+            buffer_size: int = 1,
+            flush_level: int = logging.ERROR,
+            **kwargs: Any
+    ):
+        super().__init__(buffer_size, flush_level)
+        url = URL.create(
+            drivername=drivername,
+            username=username,
+            password=password,
+            host=host,
+            port=port,
+            database=database
+        )
+        self.engine = create_engine(url, **kwargs)
+        metadata = MetaData()
+        self.log_table = Table(
+            table,
+            metadata,
+            Column('asctime', DateTime, nullable=False),
+            Column('created', Numeric(16, 6), nullable=False),  # microsecond precision
+            Column('exc_info', Text),
+            Column('filename', Text),
+            Column('func_name', Text),
+            # To support custom logging levels, use the Text data type for this column.
+            Column('levelname', Text, nullable=False),
+            # To support custom logging levels, use the BigInteger data type for this column.
+            Column('levelno', BigInteger, nullable=False),
+            Column('lineno', Integer),
+            Column('message', Text, nullable=False),
+            Column('module_name', Text),
+            Column('msecs', SmallInteger, nullable=False),  # possible range: 0-999
+            Column('logger_name', Text, nullable=False),
+            Column('pathname', Text),
+            Column('process_id', BigInteger),
+            Column('process_name', Text),
+            Column('relative_created', BigInteger, nullable=False),
+            Column('stack_info', Text),
+            Column('thread_id', BigInteger),
+            Column('thread_name', Text),
+            schema=schema
+        )
+        table_exists = False
+        if drivername == 'databricks':
+            # Checking for table existence is done manually using the information schema,
+            # as the create_all method never checks for this in Databricks, even if the checkfirst parameter is True.
+            stmt = 'select * from information_schema.tables where table_name = ?'
+            with self.engine.connect() as conn:
+                table_exists = conn.exec_driver_sql(stmt, (table,)).fetchone() is not None
+        if not table_exists:
+            metadata.create_all(self.engine)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def flush(self):
+        self.acquire()
+        try:
+            if self.buffer:
+                parameters = []
+                for record in self.buffer:
+                    exc_info = None
+                    if record.exc_info is not None:
+                        exc_type, exc_val, exc_tb = record.exc_info
+                        exc_info = ''.join(traceback.format_exception(exc_type, value=exc_val, tb=exc_tb))
+                    parameters.append(
+                        {
+                            'asctime': datetime.fromtimestamp(record.created),
+                            'created': Decimal(str(record.created)),
+                            'exc_info': exc_info,
+                            'filename': record.filename,
+                            'func_name': record.funcName,
+                            'levelname': record.levelname,
+                            'levelno': record.levelno,
+                            'lineno': record.lineno,
+                            'message': str(record.msg) % record.args,
+                            'module_name': record.module,
+                            'msecs': int(record.msecs),
+                            'logger_name': record.name,
+                            'pathname': record.pathname,
+                            'process_id': record.process,
+                            'process_name': record.processName,
+                            'relative_created': int(record.relativeCreated),
+                            'stack_info': record.stack_info,
+                            'thread_id': record.thread,
+                            'thread_name': record.threadName
+                        }
+                    )
+                with self.engine.connect() as conn:
+                    conn.execute(insert(self.log_table), parameters)
+                    conn.commit()
+                self.buffer.clear()
+        finally:
+            self.release()

sqldb_logging-0.1.1/src/sqldb_logging.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: sqldb-logging
+Version: 0.1.1
+Summary: An extension to the Python logging library that allows logging to SQL databases using SQLAlchemy
+Author-email: Ihar Shurupau <ihar.shurupau@gmail.com>
+Maintainer-email: Ihar Shurupau <ihar.shurupau@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/shurihar/sqldb-logging
+Project-URL: Issues, https://github.com/shurihar/sqldb-logging/issues
+Keywords: logging,log,logger,sql,sqldb,sqlalchemy,database,db
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=2.0.46
+Provides-Extra: databricks
+Requires-Dist: databricks-sqlalchemy>=2.0.8; extra == "databricks"
+Dynamic: license-file
+
+# sqldb-logging
+An extension to the Python logging library that allows logging to SQL databases using [SQLAlchemy](https://www.sqlalchemy.org/)
+
+## Requirements
+- Python version 3.11 or later
+
+## Installation
+
+Basic installation:
+
+```shell
+pip install sqldb-logging
+```
+
+Installation with optional dependencies:
+
+```shell
+pip install sqldb-logging[databricks]
+```
+
+## Usage
+
+```python
+import logging
+
+from sqldb_logging.handlers import SQLHandler
+
+handler = SQLHandler(
+    table='log_table',
+    drivername='postgresql+psycopg',
+    username='postgres',
+    password='postgres',
+    host='localhost',
+    port=5432,
+    database='postgres',
+    schema='public'
+)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(handler)
+logger.info('Doing something')
+```
+**Note**: The database user must have CREATE TABLE permission to create a log table if it doesn't exist.
+If the log table already exists,
+its schema must reflect the structure of [LogRecord](https://docs.python.org/3/library/logging.html#logrecord-objects)
+
+## Supported databases
+In theory, any database supported by SQLAlchemy should work. The following databases have been confirmed to work:
+- MySQL
+- PostgreSQL
+- SQLite
+- Databricks
+

sqldb_logging-0.1.1/src/sqldb_logging.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/sqldb_logging/__init__.py
+src/sqldb_logging/handlers.py
+src/sqldb_logging.egg-info/PKG-INFO
+src/sqldb_logging.egg-info/SOURCES.txt
+src/sqldb_logging.egg-info/dependency_links.txt
+src/sqldb_logging.egg-info/requires.txt
+src/sqldb_logging.egg-info/top_level.txt
+tests/test_databricks.py
+tests/test_mysql.py
+tests/test_postgres.py
+tests/test_sqlite.py

sqldb_logging-0.1.1/src/sqldb_logging.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqldb_logging-0.1.1/src/sqldb_logging.egg-info/requires.txt

@@ -0,0 +1,4 @@
+SQLAlchemy>=2.0.46
+
+[databricks]
+databricks-sqlalchemy>=2.0.8

sqldb_logging-0.1.1/src/sqldb_logging.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqldb_logging

sqldb_logging-0.1.1/tests/test_databricks.py

@@ -0,0 +1,49 @@
+import logging
+import os
+import sys
+import time
+from decimal import Decimal
+
+from sqlalchemy import select
+
+from sqldb_logging.handlers import SQLHandler
+
+
+class TestDatabricks:
+
+    def test_databricks(self):
+        start_time = time.time()
+        print(start_time)
+        handler = SQLHandler(
+            table=f'log_table_py_{sys.version_info.major}_{sys.version_info.minor}',
+            drivername='databricks',
+            username='token',
+            password=os.getenv('DATABRICKS_TOKEN'),
+            host=os.getenv('DATABRICKS_SERVER_HOSTNAME'),
+            buffer_size=10,  # this doesn't seem to work with Databricks (each record is committed in a separate txn)
+            flush_level=logging.CRITICAL,
+            connect_args={
+                'http_path': os.getenv('DATABRICKS_HTTP_PATH'),
+                'catalog': 'workspace',
+                'schema': 'default'
+            },
+            echo=True
+        )
+        logger = logging.getLogger(self.__class__.__name__)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        logger.debug('This is a %s message', logging.getLevelName(logging.DEBUG), stack_info=True)
+        logger.info('This is an %s message', logging.getLevelName(logging.INFO), stack_info=True)
+        logger.warning('This is a %s message', logging.getLevelName(logging.WARNING), stack_info=True)
+        logger.error('This is an %s message', logging.getLevelName(logging.ERROR), stack_info=True)
+        try:
+            1 / 0
+        except ZeroDivisionError as error:
+            logger.exception(error, stack_info=True)
+        logger.critical('This is a %s message', logging.getLevelName(logging.CRITICAL), stack_info=True)
+        end_time = time.time()
+        stmt = select(handler.log_table) \
+            .where(handler.log_table.c['created'] > Decimal(str(start_time))) \
+            .where(handler.log_table.c['created'] < Decimal(str(end_time)))
+        with handler.engine.connect() as conn:
+            assert len(conn.execute(stmt).fetchall()) == 6

sqldb_logging-0.1.1/tests/test_mysql.py

@@ -0,0 +1,44 @@
+import logging
+import os
+import time
+from decimal import Decimal
+
+from sqlalchemy import select
+
+from sqldb_logging.handlers import SQLHandler
+
+
+class TestMySQL:
+
+    def test_mysql(self):
+        start_time = time.time()
+        handler = SQLHandler(
+            table='log_table',
+            drivername='mysql+mysqldb',
+            username='root',
+            password=os.getenv('MYSQL_PASSWORD'),
+            host='localhost',
+            port=3306,
+            database='mysqldb',
+            buffer_size=10,
+            flush_level=logging.CRITICAL,
+            echo=True
+        )
+        logger = logging.getLogger(self.__class__.__name__)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        logger.debug('This is a %s message', logging.getLevelName(logging.DEBUG), stack_info=True)
+        logger.info('This is an %s message', logging.getLevelName(logging.INFO), stack_info=True)
+        logger.warning('This is a %s message', logging.getLevelName(logging.WARNING), stack_info=True)
+        logger.error('This is an %s message', logging.getLevelName(logging.ERROR), stack_info=True)
+        try:
+            1 / 0
+        except ZeroDivisionError as error:
+            logger.exception(error, stack_info=True)
+        logger.critical('This is a %s message', logging.getLevelName(logging.CRITICAL), stack_info=True)
+        end_time = time.time()
+        stmt = select(handler.log_table) \
+            .where(handler.log_table.c['created'] > Decimal(str(start_time))) \
+            .where(handler.log_table.c['created'] < Decimal(str(end_time)))
+        with handler.engine.connect() as conn:
+            assert len(conn.execute(stmt).fetchall()) == 6

sqldb_logging-0.1.1/tests/test_postgres.py

@@ -0,0 +1,45 @@
+import logging
+import os
+import time
+from decimal import Decimal
+
+from sqlalchemy import select
+
+from sqldb_logging.handlers import SQLHandler
+
+
+class TestPostgres:
+
+    def test_postgres(self):
+        start_time = time.time()
+        handler = SQLHandler(
+            table='log_table',
+            drivername='postgresql+psycopg',
+            username='postgres',
+            password=os.getenv('POSTGRES_PASSWORD'),
+            host='localhost',
+            port=5432,
+            database='postgres',
+            schema='public',
+            buffer_size=10,
+            flush_level=logging.CRITICAL,
+            echo=True
+        )
+        logger = logging.getLogger(self.__class__.__name__)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        logger.debug('This is a %s message', logging.getLevelName(logging.DEBUG), stack_info=True)
+        logger.info('This is an %s message', logging.getLevelName(logging.INFO), stack_info=True)
+        logger.warning('This is a %s message', logging.getLevelName(logging.WARNING), stack_info=True)
+        logger.error('This is an %s message', logging.getLevelName(logging.ERROR), stack_info=True)
+        try:
+            1 / 0
+        except ZeroDivisionError as error:
+            logger.exception(error, stack_info=True)
+        logger.critical('This is a %s message', logging.getLevelName(logging.CRITICAL), stack_info=True)
+        end_time = time.time()
+        stmt = select(handler.log_table) \
+            .where(handler.log_table.c['created'] > Decimal(str(start_time))) \
+            .where(handler.log_table.c['created'] < Decimal(str(end_time)))
+        with handler.engine.connect() as conn:
+            assert len(conn.execute(stmt).fetchall()) == 6

sqldb_logging-0.1.1/tests/test_sqlite.py

@@ -0,0 +1,40 @@
+import logging
+import os
+import time
+from decimal import Decimal
+
+from sqlalchemy import select
+
+from sqldb_logging.handlers import SQLHandler
+
+
+class TestSQLite:
+
+    def test_sqlite(self, tmp_path):
+        start_time = time.time()
+        handler = SQLHandler(
+            table='log_table',
+            drivername='sqlite',
+            database=os.path.join(tmp_path, 'sqlite.db'),
+            buffer_size=10,
+            flush_level=logging.CRITICAL,
+            echo=True
+        )
+        logger = logging.getLogger(self.__class__.__name__)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        logger.debug('This is a %s message', logging.getLevelName(logging.DEBUG), stack_info=True)
+        logger.info('This is an %s message', logging.getLevelName(logging.INFO), stack_info=True)
+        logger.warning('This is a %s message', logging.getLevelName(logging.WARNING), stack_info=True)
+        logger.error('This is an %s message', logging.getLevelName(logging.ERROR), stack_info=True)
+        try:
+            1 / 0
+        except ZeroDivisionError as error:
+            logger.exception(error, stack_info=True)
+        logger.critical('This is a %s message', logging.getLevelName(logging.CRITICAL), stack_info=True)
+        end_time = time.time()
+        stmt = select(handler.log_table) \
+            .where(handler.log_table.c['created'] > Decimal(str(start_time))) \
+            .where(handler.log_table.c['created'] < Decimal(str(end_time)))
+        with handler.engine.connect() as conn:
+            assert len(conn.execute(stmt).fetchall()) == 6