channel-app 0.0.155__tar.gz → 0.0.157a1__tar.gz

{channel_app-0.0.155/channel_app.egg-info → channel_app-0.0.157a1}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.1
 Name: channel_app
-Version: 0.0.155
+Version: 0.0.157a1
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam
 Classifier: Development Status :: 5 - Production/Stable
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
-Requires-Dist: requests

channel_app-0.0.157a1/alembic.ini

@@ -0,0 +1,119 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+# Use forward slashes (/) also on windows to provide an os agnostic path
+script_location = channel_app/database/migrations
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to migrations/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+# version_path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+version_path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = postgresql+psycopg2://postgres:12345@127.0.0.1/sales_channel_logs
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

{channel_app-0.0.155 → channel_app-0.0.157a1}/bitbucket-pipelines.yml

@@ -1,4 +1,4 @@
-image: python:3.8.10
+image: python:3.11.9
 
 pipelines:
   pull-requests:
@@ -16,7 +16,7 @@ pipelines:
     '*':
       - step:
           name: Publish to PyPI
-          image: python:3.7-alpine
+          image: python:3.11.9-alpine
           script:
             - apk add gcc git libffi-dev musl-dev openssl-dev python3-dev
             - pip install setuptools setuptools_scm twine

{channel_app-0.0.155 → channel_app-0.0.157a1}/channel_app/app/order/service.py

@@ -1,3 +1,4 @@
+import uuid
 from dataclasses import asdict
 from typing import List, Generator, Union
 
@@ -19,6 +20,7 @@ from channel_app.core.data import (BatchRequestResponseDto,
                                    CancelOrderDto,
                                    ChannelUpdateOrderItemDto)
 from channel_app.core.settings import OmnitronIntegration, ChannelIntegration
+from channel_app.logs.services import LogService
 from channel_app.omnitron.batch_request import ClientBatchRequest
 from channel_app.omnitron.constants import (BatchRequestStatus, ContentType, 
                                             FailedReasonType)
@@ -33,48 +35,87 @@ class OrderService(object):
     batch_service = ClientBatchRequest
 
     def fetch_and_create_order(self, is_success_log=True):
-        with OmnitronIntegration(
-                content_type=ContentType.order.value) as omnitron_integration:
-            get_orders = ChannelIntegration().do_action(
-                key='get_orders',
-                batch_request=omnitron_integration.batch_request
-            )
-
-            get_orders: Generator
-            order_batch_objects = []
-            while True:
-                try:
-                    channel_create_order, report_list, _ = next(get_orders)
-                except StopIteration:
-                    break
-
-                # tips
-                channel_create_order: ChannelCreateOrderDto
-                report_list: List[ErrorReportDto]
-                for report in report_list:
-                    if is_success_log or not report.is_ok:
-                        report.error_code = \
-                            f"{omnitron_integration.batch_request.local_batch_id}" \
-                            f"-Channel-GetOrders_{channel_create_order.order.number}"
-                        omnitron_integration.do_action(
-                            key='create_error_report',
-                            objects=report)
+        log_service = LogService()
+        tx_id = uuid.uuid4()
+        log_service.create_flow(
+            name="OrderSync",
+            transaction_id=tx_id,
+        )
 
-                order = self.create_order(omnitron_integration=omnitron_integration,
-                                          channel_order=channel_create_order)
-                if order and omnitron_integration.batch_request.objects:
-                    order_batch_objects.extend(omnitron_integration.batch_request.objects)
-
-            omnitron_integration.batch_request.objects = order_batch_objects
-            try:
-                self.batch_service(settings.OMNITRON_CHANNEL_ID).to_done(
-                    batch_request=omnitron_integration.batch_request
-                )
-            except requests_exceptions.HTTPError as exc:
-                if exc.response.status_code == 406 and "batch_request_status_100_1" in exc.response.text:
-                    pass
-                else:
-                    raise exc
+        try:
+            with log_service.step("fetch_orders"):
+                with OmnitronIntegration(
+                        content_type=ContentType.order.value
+                    ) as omnitron_integration:
+
+                    with log_service.step("get_orders"):
+                        get_orders = ChannelIntegration().do_action(
+                            key='get_orders',
+                            batch_request=omnitron_integration.batch_request
+                        )
+
+                    get_orders: Generator
+                    order_batch_objects = []
+                    while True:
+                        try:
+                            channel_create_order, report_list, _ = next(get_orders)
+                        except StopIteration:
+                            break
+
+                        # tips
+                        channel_create_order: ChannelCreateOrderDto
+                        metadata = {
+                            "order_number": channel_create_order.order.number
+                        }
+
+                        report_list: List[ErrorReportDto]
+                        for report in report_list:
+                            if is_success_log or not report.is_ok:
+                                report.error_code = \
+                                    f"{omnitron_integration.batch_request.local_batch_id}" \
+                                    f"-Channel-GetOrders_{channel_create_order.order.number}"
+                                try:
+                                    
+                                    with log_service.step("create_error_report", metadata=metadata):
+                                        omnitron_integration.do_action(
+                                            key='create_error_report',
+                                            objects=report
+                                        )
+                                except Exception as err:
+                                    log_service.add_exception(err)
+                                    raise
+                        
+                        try:
+                            with log_service.step("create_order", metadata=metadata):
+                                order = self.create_order(
+                                    omnitron_integration=omnitron_integration,
+                                    channel_order=channel_create_order
+                                )
+                        except Exception as err:
+                            log_service.add_exception(err)
+                            raise
+
+                        if order and omnitron_integration.batch_request.objects:
+                            order_batch_objects.extend(omnitron_integration.batch_request.objects)
+
+                    omnitron_integration.batch_request.objects = order_batch_objects
+                    
+                    with log_service.step("batch_to_done"):
+                        try:
+                            self.batch_service(settings.OMNITRON_CHANNEL_ID).to_done(
+                                batch_request=omnitron_integration.batch_request
+                            )
+                        except requests_exceptions.HTTPError as exc:
+                            log_service.add_exception(exc)
+                            if exc.response.status_code == 406 and "batch_request_status_100_1" in exc.response.text:
+                                pass
+                            else:
+                                raise exc
+        except Exception as fatal:
+            log_service.add_exception(fatal)
+            raise
+        finally:
+            log_service.save()
 
     def create_order(self, omnitron_integration: OmnitronIntegration,
                      channel_order: ChannelCreateOrderDto

{channel_app-0.0.155 → channel_app-0.0.157a1}/channel_app/core/settings.py

@@ -17,6 +17,7 @@ CACHE_PORT = os.getenv("CACHE_PORT")
 BROKER_HOST = os.getenv("BROKER_HOST")
 BROKER_PORT = os.getenv("BROKER_PORT")
 BROKER_DATABASE_INDEX = os.getenv("BROKER_DATABASE_INDEX")
+DATABASE_URI = os.getenv("DATABASE_URI")
 SENTRY_DSN = os.getenv("SENTRY_DSN")
 DEFAULT_CONNECTION_POOL_COUNT = os.getenv("DEFAULT_CONNECTION_POOL_COUNT") or 10
 DEFAULT_CONNECTION_POOL_MAX_SIZE = os.getenv("DEFAULT_CONNECTION_POOL_COUNT") or 10

channel_app-0.0.157a1/channel_app/database/migrations/README

@@ -0,0 +1 @@
+Generic single-database configuration.

channel_app-0.0.157a1/channel_app/database/migrations/env.py

@@ -0,0 +1,86 @@
+import os
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from channel_app.database.models import Base as BaseModel
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = BaseModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    
+    DATABASE_URL = os.getenv("DATABASE_URI")
+    if DATABASE_URL:
+        url = config.set_main_option("sqlalchemy.url", DATABASE_URL)
+
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

channel_app-0.0.157a1/channel_app/database/migrations/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

channel_app-0.0.157a1/channel_app/database/migrations/versions/6049560b1ecb_create_flow_logs.py

@@ -0,0 +1,43 @@
+"""create flow_logs
+
+Revision ID: 6049560b1ecb
+Revises: 
+Create Date: 2025-04-22 15:53:37.986109
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '6049560b1ecb'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('log_flows',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('transaction_id', sa.UUID(), nullable=False),
+    sa.Column('flow_name', sa.String(length=255), nullable=False),
+    sa.Column('flow_author', sa.Enum('user', 'system', name='logflowauthor'), nullable=False),
+    sa.Column('started_at', sa.DateTime(timezone=True), nullable=False),
+    sa.Column('ended_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('status', sa.Enum('in_progress', 'success', 'failure', name='logstepstatus'), nullable=True),
+    sa.Column('s3_key', sa.Text(), nullable=True),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('transaction_id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('log_flows')
+    # ### end Alembic commands ###

channel_app-0.0.157a1/channel_app/database/migrations/versions/881a968ee603_add_step_and_exception_logs.py

@@ -0,0 +1,55 @@
+"""add step and exception logs
+
+Revision ID: 881a968ee603
+Revises: 6049560b1ecb
+Create Date: 2025-04-24 11:58:59.377131
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '881a968ee603'
+down_revision: Union[str, None] = '6049560b1ecb'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('log_steps',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('flow_id', sa.UUID(), nullable=False),
+    sa.Column('step_name', sa.String(length=255), nullable=False),
+    sa.Column('status', sa.Enum('in_progress', 'success', 'failure', name='logstepstatus', native_enum=False), nullable=False),
+    sa.Column('start_time', sa.DateTime(timezone=True), nullable=False),
+    sa.Column('end_time', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('duration_ms', sa.Integer(), nullable=True),
+    sa.Column('error_message', sa.String(), nullable=True),
+    sa.Column('step_metadata', sa.JSON(), nullable=True),
+    sa.ForeignKeyConstraint(['flow_id'], ['log_flows.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('log_step_exceptions',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('step_id', sa.UUID(), nullable=False),
+    sa.Column('type', sa.String(length=128), nullable=False),
+    sa.Column('message', sa.String(), nullable=True),
+    sa.Column('traceback', sa.String(), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
+    sa.ForeignKeyConstraint(['step_id'], ['log_steps.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('log_step_exceptions')
+    op.drop_table('log_steps')
+    # ### end Alembic commands ###

channel_app-0.0.157a1/channel_app/database/models.py

@@ -0,0 +1,58 @@
+from datetime import datetime, timezone
+import uuid
+from sqlalchemy import JSON, Column, DateTime, ForeignKey, Integer, String, Enum as SqlEnum, Text
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import DeclarativeBase, relationship
+
+from channel_app.logs.enums import LogFlowAuthor, LogStepStatus
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class LogFlowModel(Base):
+    __tablename__ = "log_flows"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    transaction_id = Column(UUID(as_uuid=True), unique=True, nullable=False)
+    flow_name = Column(String(255), nullable=False)
+    flow_author = Column(SqlEnum(LogFlowAuthor), default=LogFlowAuthor.system, nullable=False)
+
+    started_at = Column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(timezone.utc))
+    ended_at = Column(DateTime(timezone=True), nullable=True)
+
+    status = Column(SqlEnum(LogStepStatus), nullable=True)
+    s3_key = Column(Text, nullable=True)
+
+    def __repr__(self):
+        return f"<FlowLog(transaction_id={self.transaction_id}, flow_name={self.flow_name})>"
+    
+
+class LogStepModel(Base):
+    __tablename__ = "log_steps"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    flow_id = Column(UUID(as_uuid=True), ForeignKey("log_flows.id", ondelete="CASCADE"), nullable=False)
+    step_name = Column(String(255), nullable=False)
+    status = Column(SqlEnum(LogStepStatus, native_enum=False), nullable=False)
+    start_time = Column(DateTime(timezone=True), nullable=False)
+    end_time = Column(DateTime(timezone=True))
+    duration_ms = Column(Integer)
+    error_message = Column(String)
+    step_metadata = Column(JSON)
+
+    exceptions = relationship("LogStepExceptionModel", back_populates="step", cascade="all, delete-orphan")
+    
+
+class LogStepExceptionModel(Base):
+    __tablename__ = "log_step_exceptions"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    step_id = Column(UUID(as_uuid=True), ForeignKey("log_steps.id", ondelete="CASCADE"), nullable=False)
+    type = Column(String(128), nullable=False)
+    message = Column(String)
+    traceback = Column(String)
+    created_at = Column(DateTime(timezone=True), nullable=False)
+
+    step = relationship("LogStepModel", back_populates="exceptions")

channel_app-0.0.157a1/channel_app/database/services.py

@@ -0,0 +1,8 @@
+from sqlalchemy import create_engine
+from channel_app.core import settings
+
+
+class DatabaseService:
+    def create_engine(self):
+        engine = create_engine(settings.DATABASE_URI, echo=False)
+        return engine

channel_app-0.0.157a1/channel_app/logs/enums.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class LogStepStatus(str, Enum):
+    in_progress = "IN_PROGRESS"
+    success = "SUCCESS"
+    failure = "FAILURE"
+
+
+class LogFlowAuthor(str, Enum):
+    user = "User"
+    system = "System"
+    

channel_app-0.0.157a1/channel_app/logs/services.py

@@ -0,0 +1,160 @@
+from contextlib import contextmanager
+import traceback
+from typing import Optional
+import uuid
+from datetime import datetime, timezone
+from sqlalchemy.orm import scoped_session, sessionmaker
+
+from channel_app.database.models import LogFlowModel, LogStepExceptionModel, LogStepModel
+from channel_app.database.services import DatabaseService
+from channel_app.logs.enums import LogFlowAuthor, LogStepStatus
+
+
+class LogService:
+    database_service = DatabaseService()
+
+    def __init__(self):
+        self.flow = {}
+        self.steps = []
+        self.exceptions = []
+        
+        self.db_engine = self.database_service.create_engine()
+        self.s3_client = None # TODO: Declare the boto3 client
+        self.s3_bucket = None # TODO: Get s3 bucket from exported environment variables
+
+    def create_flow(
+        self, 
+        name: str, 
+        transaction_id: str, 
+        flow_author: LogFlowAuthor = LogFlowAuthor.system
+    ):
+        self.flow = {
+            "id": uuid.uuid4(),
+            "transaction_id": transaction_id or str(uuid.uuid4()),
+            "flow_name": name,
+            "flow_author": flow_author.value,
+            "started_at": datetime.now(timezone.utc)
+        }
+
+    @contextmanager
+    def step(self, name: str, metadata: Optional[dict] = None):
+        now = datetime.now(timezone.utc)
+        self._add_step(name, start=True, metadata=metadata)
+        try:
+            yield
+            self._add_step(name, end=True)
+        except Exception as exc:
+            self.add_exception(exc)
+            for step in reversed(self.steps):
+                if step["step_name"] == name and step.get("status") == LogStepStatus.in_progress.value:
+                    step["end_time"] = now
+                    step["status"] = LogStepStatus.failure.value
+                    step["error"] = str(exc)
+                    break
+            raise
+
+
+    def _add_step(self, name, start=False, end=False, metadata=None):
+        now = datetime.now(timezone.utc)
+        if start:
+            self.steps.append(
+                {
+                    "id": uuid.uuid4(),
+                    "step_name": name,
+                    "start_time": now,
+                    "status": LogStepStatus.in_progress.value,
+                    "metadata": metadata or {},
+                }
+            )
+        elif end:
+            for step in reversed(self.steps):
+                if step["step_name"] == name and step["status"] == LogStepStatus.in_progress.value:
+                    step["end_time"] = now
+                    step["status"] = LogStepStatus.success.value
+                    step["duration_ms"] = int((now - step["start_time"]).total_seconds() * 1000)
+
+    def add_exception(self, exc: Exception):
+        tb = traceback.format_exc()
+        exc_obj = {
+            "id": uuid.uuid4(),
+            "type": type(exc).__name__,
+            "message": str(exc),
+            "traceback": tb
+        }
+        self.exceptions.append(exc_obj)
+        # If this flow has related step, update the step to FAILURE
+        if self.steps:
+            self.steps[-1]["status"] = LogStepStatus.failure.value
+            self.steps[-1]["error"] = str(exc)
+            self.steps[-1].setdefault("exceptions", []).append(exc_obj)
+
+    def save(self):
+        self.flow["ended_at"] = datetime.now(timezone.utc)
+        full_log_content = {
+            **self.flow,
+            "steps": self.steps,
+            "exceptions": self.exceptions,
+        }
+        s3_key = f"logs/{self.flow['flow_name']}/{self.flow['transaction_id']}.json"
+
+        self._upload_to_s3(s3_key, full_log_content)
+        
+
+        log_flow_object = LogFlowModel(
+            id=self.flow["id"],
+            transaction_id=str(self.flow["transaction_id"]),
+            flow_name=self.flow["flow_name"],
+            flow_author=self.flow["flow_author"],
+            started_at=self.flow["started_at"],
+            ended_at=self.flow["ended_at"],
+            status=self.steps[-1]["status"] if self.steps else LogStepStatus.failure.value,
+            s3_key=s3_key,
+        )
+        
+        step_models = []
+        exception_models = []
+        for step in self.steps:
+            step_model = LogStepModel(
+                id=step["id"],
+                flow_id=self.flow["id"],
+                step_name=step["step_name"],
+                status=step["status"],
+                start_time=step["start_time"],
+                end_time=step.get("end_time"),
+                duration_ms=step.get("duration_ms"),
+                error_message=step.get("error"),
+                step_metadata=step.get("metadata"),
+            )
+            step_models.append(step_model)
+
+            for exc in step.get("exceptions", []):
+                exception_models.append(
+                    LogStepExceptionModel(
+                        id=exc["id"],
+                        step_id=step["id"],
+                        type=exc["type"],
+                        message=exc["message"],
+                        traceback=exc["traceback"],
+                        created_at=self.flow["ended_at"],
+                    )
+                )
+        
+        self._save_to_db(log_flow_object, step_models, exception_models)
+
+    def _upload_to_s3(self, key: str, content: dict):
+        # TODO: Implement this.
+        pass
+
+    def _save_to_db(self, flow_obj, step_objs, exception_objs):
+        session = scoped_session(sessionmaker(bind=self.db_engine))
+        try:
+            session.add(flow_obj)
+            session.add_all(step_objs)
+            if exception_objs:
+                session.add_all(exception_objs)
+            session.commit()
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()

{channel_app-0.0.155 → channel_app-0.0.157a1/channel_app.egg-info}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.1
-Name: channel_app
-Version: 0.0.155
+Name: channel-app
+Version: 0.0.157a1
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam
 Classifier: Development Status :: 5 - Production/Stable
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
-Requires-Dist: requests

{channel_app-0.0.155 → channel_app-0.0.157a1}/channel_app.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ Makefile
 Procfile-dist
 README.md
 akinon.json-dist
+alembic.ini
 bitbucket-pipelines.yml
 build.sh-dist
 requirements-dev.txt
@@ -49,6 +50,17 @@ channel_app/core/products.py
 channel_app/core/settings.py
 channel_app/core/tests.py
 channel_app/core/utilities.py
+channel_app/database/__init__.py
+channel_app/database/models.py
+channel_app/database/services.py
+channel_app/database/migrations/README
+channel_app/database/migrations/env.py
+channel_app/database/migrations/script.py.mako
+channel_app/database/migrations/versions/6049560b1ecb_create_flow_logs.py
+channel_app/database/migrations/versions/881a968ee603_add_step_and_exception_logs.py
+channel_app/logs/__init__.py
+channel_app/logs/enums.py
+channel_app/logs/services.py
 channel_app/omnitron/__init__.py
 channel_app/omnitron/batch_request.py
 channel_app/omnitron/constants.py

{channel_app-0.0.155 → channel_app-0.0.157a1}/requirements.txt

@@ -6,3 +6,6 @@ omnisdk
 setuptools>=65.5.1 # not directly required, pinned by Snyk to avoid a vulnerability
 redis==5.0.1
 python-dotenv
+sqlalchemy==2.0.40
+psycopg2-binary==2.9.10
+alembic==1.15.2

{channel_app-0.0.155 → channel_app-0.0.157a1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md") as f:
 
 setup(
     name="channel_app",
-    version="0.0.155",
+    version="0.0.157a1", # alpha prerelease
     packages=find_packages(),
     url="https://github.com/akinon/channel_app",
     description="Channel app for Sales Channels",

{channel_app-0.0.155 → channel_app-0.0.157a1}/tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py35,py36,py37,py38,py39
+envlist = py35,py36,py37,py38,py39,py310,py311
 
 [testenv]
 # install pytest in the virtualenv where commands will be executed