channel-app 0.0.156__py3-none-any.whl → 0.0.157a2__py3-none-any.whl

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/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/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/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/logs/encoders.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+import json
+import uuid
+
+
+class UUIDEncoder(json.JSONEncoder):
+    """
+    Custom JSON encoder that handles UUID and datetime objects.
+    
+    This encoder extends the standard JSONEncoder to properly serialize:
+    - UUID objects (converted to strings)
+    - datetime objects (converted to ISO format)
+    """
+    def default(self, obj):
+        if isinstance(obj, uuid.UUID):
+            # Convert UUID to string
+            return str(obj)
+        elif isinstance(obj, datetime):
+            # Convert datetime to ISO format string
+            return obj.isoformat()
+        # Let the base class handle other types or raise TypeError
+        return super().default(obj)

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/logs/services.py

@@ -0,0 +1,212 @@
+from contextlib import contextmanager
+import json
+import os
+import traceback
+from typing import Optional
+import uuid
+from datetime import datetime, timezone
+import boto3
+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.encoders import UUIDEncoder
+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 = S3Client()
+
+    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.s3_client.upload_object(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 _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()
+
+
+class S3Client:
+    def __init__(self):
+        self._validate_credentials()
+        self.client = boto3.client("s3")
+        self.bucket = os.getenv("LOGGING_S3_BUCKET", "default-bucket-name")
+
+    def _validate_credentials(self):
+        required_env_vars = {
+            "AWS_ACCESS_KEY_ID": os.getenv("AWS_ACCESS_KEY_ID"),
+            "AWS_SECRET_ACCESS_KEY": os.getenv("AWS_SECRET_ACCESS_KEY"),
+            "AWS_REGION": os.getenv("AWS_REGION"),
+            "LOGGING_S3_BUCKET": os.getenv("LOGGING_S3_BUCKET"),
+        }
+
+        missing_vars = [
+            name for name, value in required_env_vars.items() if value is None
+        ]
+
+        if missing_vars:
+            raise ValueError(
+                f"S3 Client initialization failed: missing AWS credentials: {', '.join(missing_vars)}"
+            )
+
+    def set_bucket(self, bucket_name: str):
+        self.bucket = bucket_name
+        return self
+
+    def upload_object(self, key: str, content: dict):
+        try:
+            body = json.dumps(content, indent=2, cls=UUIDEncoder).encode("utf-8")
+            self.client.put_object(
+                Bucket=self.bucket,
+                Key=key,
+                Body=body,
+                ContentType="application/json",
+            )
+        except Exception as e:
+            print(f"[S3 Upload Error] {e}")
+            raise

{channel_app-0.0.156.dist-info → channel_app-0.0.157a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: channel-app
-Version: 0.0.156
+Version: 0.0.157a2
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam

{channel_app-0.0.156.dist-info → channel_app-0.0.157a2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 channel_app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/app/order/service.py,sha256=DXxMNqC8ltz582m7stlwXX_yRoCp3NzrkVlzpBGGPA4,20454
+channel_app/app/order/service.py,sha256=GZ8StGwvICtI0DWMtYFq1mB9GPdojNpjCh9oVrHlHJE,22366
 channel_app/app/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/product/service.py,sha256=7DZF-Vtoaf5eKT1m_ccEOAqUxWSO7Csop4HEtJmcrvw,10646
 channel_app/app/product_image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -29,9 +29,16 @@ channel_app/core/commands.py,sha256=wM0ZlH_GHaYLKy2SWab_aKuZCsSahUuHeBa_tqi3W4A,
 channel_app/core/data.py,sha256=SlsXB0MW0epC2nrM0uEnaCBYK3Nz0kXFXZ1n4t8iomg,6931
 channel_app/core/integration.py,sha256=OqpN8B3KBLsjjrbZXZaNVF6NtObejh7P_7kGFj1xU3o,2817
 channel_app/core/products.py,sha256=uInjFw-vze1XP8vWEeq4VWDZVQQIiatoe1YsQ6n_H5E,2092
-channel_app/core/settings.py,sha256=1KF8PhbjEqyZOWese9EFA_DnaSA1eVcscfShVIroTRo,1247
+channel_app/core/settings.py,sha256=ZkEiumBmRSBXd4W7RdyHrTwj7Un0Ynktab1zr8N_86I,1288
 channel_app/core/tests.py,sha256=ucgnLyb3D8H2JvjjH6icdRZzZQoMFbnlnFLylhoJ0Js,434
 channel_app/core/utilities.py,sha256=3iSU4RHFSsdTWBfUYBK23CRGtAIC-nYIBIJLm0Dlx3o,4168
+channel_app/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+channel_app/database/models.py,sha256=cdjLcfJe-OYZzk1fl3JL6ght8jryRYLwMF2uV3srM-o,2314
+channel_app/database/services.py,sha256=0zHLAcJAKRU6hKEaS9DmsX_2gIE29hh__DfHHx3JuSE,216
+channel_app/logs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+channel_app/logs/encoders.py,sha256=6CVgtkV7DrjxGpNXCJgT9bn9B2Ep0lHgtm-0ES7A57I,703
+channel_app/logs/enums.py,sha256=If6ZjwRTerbJypYI8WjdsleHR7FjlV-TP2nBppFVEc4,214
+channel_app/logs/services.py,sha256=O488OStOe9C-2AIU34bjHEBB3_XywgGlLEn77JJHUu4,7173
 channel_app/omnitron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/omnitron/batch_request.py,sha256=S8IHtbI1RtVLbnOwtfXSmkrREGp8wUYW2E-eu5omwyY,3550
 channel_app/omnitron/constants.py,sha256=WZR6k_k2zZfN7lfi1ZLv1PphsHIq_LiZgw6Nd6LduvE,2793
@@ -58,7 +65,7 @@ channel_app/omnitron/commands/tests/test_product_images.py,sha256=y6tmiJ00kd2GTq
 channel_app/omnitron/commands/tests/test_product_prices.py,sha256=5HPX9PmjGw6gk3oNrwtWLqdrOkfeNx1mYP-pYwOesZU,3496
 channel_app/omnitron/commands/tests/test_product_stocks.py,sha256=q4RGlrCNUUJyN5CBL1fzrvdd4Q3xt816mbMRQT0XEd0,3496
 channel_app/omnitron/commands/tests/test_products.py,sha256=uj5KLaubY3XNu0hidOH-u-Djfboe81Hj7-lP--01Le0,103494
-channel_app-0.0.156.dist-info/METADATA,sha256=-IM5ZVIX0v5FLJW6rtRKJjppI4poy0ad9_fde-O4emc,309
-channel_app-0.0.156.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-channel_app-0.0.156.dist-info/top_level.txt,sha256=JT-gM6L5Cwxr1xEoN7NHrREDs-d6iGFGfRnK-NrJ3tU,12
-channel_app-0.0.156.dist-info/RECORD,,
+channel_app-0.0.157a2.dist-info/METADATA,sha256=qyT2b6_Y3MwOreXTMrwfW3D113VS133PS5sAKy711OI,311
+channel_app-0.0.157a2.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+channel_app-0.0.157a2.dist-info/top_level.txt,sha256=JT-gM6L5Cwxr1xEoN7NHrREDs-d6iGFGfRnK-NrJ3tU,12
+channel_app-0.0.157a2.dist-info/RECORD,,