dotflow 0.15.0.dev1__tar.gz → 0.15.0.dev2__tar.gz

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotflow
-Version: 0.15.0.dev1
+Version: 0.15.0.dev2
 Summary: 🎲 Dotflow turns an idea into flow! Lightweight Python library for execution pipelines with retry, parallel, cron and async support.
 License: MIT License
          
@@ -44,9 +44,12 @@ Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: aws
 Provides-Extra: deploy-aws
 Provides-Extra: deploy-gcp
+Provides-Extra: deploy-github
 Provides-Extra: gcp
 Provides-Extra: otel
 Provides-Extra: scheduler
+Provides-Extra: sentry
+Requires-Dist: PyGithub ; extra == "deploy-github"
 Requires-Dist: boto3 ; extra == "aws"
 Requires-Dist: boto3 ; extra == "deploy-aws"
 Requires-Dist: cookiecutter (>=2.0)
@@ -63,6 +66,7 @@ Requires-Dist: opentelemetry-sdk ; extra == "otel"
 Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: rich
+Requires-Dist: sentry-sdk ; extra == "sentry"
 Requires-Dist: typing-extensions
 Project-URL: Changelog, https://dotflow-io.github.io/dotflow/nav/development/release-notes/
 Project-URL: Documentation, https://dotflow-io.github.io/dotflow/

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/dotflow/__init__.py

@@ -1,6 +1,6 @@
 """Dotflow __init__ module."""
 
-__version__ = "0.15.0.dev1"
+__version__ = "0.15.0.dev2"
 __description__ = "🎲 Dotflow turns an idea into flow!"
 
 from .core.action import Action as action

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/dotflow/cli/commands/deploy.py

@@ -6,15 +6,15 @@ from dotflow.cli.command import Command
 from dotflow.settings import Settings as settings
 
 SAM_PLATFORMS = {
-    "lambda-s3-trigger",
-    "lambda-sqs-trigger",
-    "lambda-api-trigger",
     "ecs-scheduled",
 }
 
 DEFAULT_REGIONS = {
     "lambda": "us-east-1",
     "lambda-scheduled": "us-east-1",
+    "lambda-s3-trigger": "us-east-1",
+    "lambda-sqs-trigger": "us-east-1",
+    "lambda-api-trigger": "us-east-1",
     "ecs": "us-east-1",
     "cloud-run": "us-central1",
     "cloud-run-scheduled": "us-central1",
@@ -41,9 +41,13 @@ class DeployCommand(Command):
         deployers = {
             "lambda": self._deploy_lambda,
             "lambda-scheduled": self._deploy_lambda,
+            "lambda-s3-trigger": self._deploy_lambda_s3,
+            "lambda-sqs-trigger": self._deploy_lambda_sqs,
+            "lambda-api-trigger": self._deploy_lambda_api,
             "ecs": self._deploy_ecs,
             "cloud-run": self._deploy_cloud_run,
             "cloud-run-scheduled": self._deploy_cloud_run,
+            "github-actions": self._deploy_github_actions,
         }
 
         handler = deployers.get(platform)
@@ -63,6 +67,27 @@ class DeployCommand(Command):
         deployer = LambdaDeployer(region=region)
         deployer.deploy(name, schedule=schedule)
 
+    def _deploy_lambda_api(self, name: str, region: str, **kwargs):
+        """Deploy to AWS Lambda + API Gateway."""
+        from dotflow.cloud.aws import LambdaApiDeployer
+
+        deployer = LambdaApiDeployer(region=region)
+        deployer.deploy(name)
+
+    def _deploy_lambda_s3(self, name: str, region: str, **kwargs):
+        """Deploy to AWS Lambda + S3 Trigger."""
+        from dotflow.cloud.aws import LambdaS3Deployer
+
+        deployer = LambdaS3Deployer(region=region)
+        deployer.deploy(name)
+
+    def _deploy_lambda_sqs(self, name: str, region: str, **kwargs):
+        """Deploy to AWS Lambda + SQS Trigger."""
+        from dotflow.cloud.aws import LambdaSQSDeployer
+
+        deployer = LambdaSQSDeployer(region=region)
+        deployer.deploy(name)
+
     def _deploy_ecs(self, name: str, region: str, **kwargs):
         """Deploy to AWS ECS Fargate."""
         from dotflow.cloud.aws import ECSDeployer
@@ -76,3 +101,10 @@ class DeployCommand(Command):
 
         deployer = CloudRunDeployer(region=region)
         deployer.deploy(name)
+
+    def _deploy_github_actions(self, name: str, **kwargs):
+        """Deploy to GitHub Actions."""
+        from dotflow.cloud.github import ActionsDeployer
+
+        deployer = ActionsDeployer()
+        deployer.deploy(name)

dotflow-0.15.0.dev2/dotflow/cloud/aws/__init__.py

@@ -0,0 +1,15 @@
+"""AWS deploy module."""
+
+from dotflow.cloud.aws.ecs_deployer import ECSDeployer
+from dotflow.cloud.aws.lambda_api_deployer import LambdaApiDeployer
+from dotflow.cloud.aws.lambda_deployer import LambdaDeployer
+from dotflow.cloud.aws.lambda_s3_deployer import LambdaS3Deployer
+from dotflow.cloud.aws.lambda_sqs_deployer import LambdaSQSDeployer
+
+__all__ = [
+    "LambdaDeployer",
+    "LambdaApiDeployer",
+    "LambdaS3Deployer",
+    "LambdaSQSDeployer",
+    "ECSDeployer",
+]

dotflow-0.15.0.dev1/dotflow/cloud/aws/lambda_deployer.py → dotflow-0.15.0.dev2/dotflow/cloud/aws/base_lambda_deployer.py

@@ -1,9 +1,7 @@
-"""Lambda deployment."""
+"""Base Lambda deployment — shared logic for all Lambda variants."""
 
 from __future__ import annotations
 
-import contextlib
-
 from rich import print  # type: ignore
 
 from dotflow.cloud.aws.constants import BOTO3_NOT_FOUND, CREDENTIALS_NOT_FOUND
@@ -14,8 +12,8 @@ from dotflow.cloud.core import Deployer
 from dotflow.settings import Settings as settings
 
 
-class LambdaDeployer(Deployer):
-    """Deploy dotflow pipelines to AWS Lambda."""
+class BaseLambdaDeployer(Deployer):
+    """Shared logic for all Lambda deployers."""
 
     def __init__(self, region: str = "us-east-1"):
         try:
@@ -30,8 +28,8 @@ class LambdaDeployer(Deployer):
             raise SystemExit(CREDENTIALS_NOT_FOUND) from err
 
         self._region = region
+        self._boto3 = boto3
         self._lambda = boto3.client("lambda", region_name=region)
-        self._events = boto3.client("events", region_name=region)
 
         self._ecr = ECR(
             boto3.client("ecr", region_name=region),
@@ -41,34 +39,47 @@ class LambdaDeployer(Deployer):
         self._iam = IAM(boto3.client("iam", region_name=region))
         self._logs = CloudWatch(boto3.client("logs", region_name=region))
 
+    @property
+    def _function_arn(self) -> str:
+        return (
+            f"arn:aws:lambda:{self._region}:{self._account_id}"
+            f":function:{self._name}"
+        )
+
     def setup(self, name: str) -> None:
         """Create IAM role and CloudWatch log group."""
+        self._name = name
         self._role_arn = self._iam.ensure_lambda_role(name)
         self._logs.ensure_log_group(f"/aws/lambda/{name}")
 
-    def deploy(self, name: str, **kwargs) -> None:
-        """Deploy a Lambda function from the current directory."""
-        schedule = kwargs.get("schedule")
+    def ensure_roles(self, name: str) -> str:
+        """Create or get Lambda execution role."""
+        return self._iam.ensure_lambda_role(name)
 
-        print(settings.INFO_ALERT, f"Deploying Lambda '{name}'...")
+    def ensure_logs(self, name: str) -> None:
+        """Create CloudWatch log group."""
+        self._logs.ensure_log_group(f"/aws/lambda/{name}")
+
+    def deploy(self, name: str, **kwargs) -> None:
+        """Deploy Lambda and configure trigger."""
+        print(settings.INFO_ALERT, f"Deploying '{name}'...")
 
         self.setup(name)
         image_uri = self._ecr.push(name)
-        self._create_or_update(name, image_uri, self._role_arn)
-
-        if schedule:
-            self._create_schedule(name, schedule)
+        self._create_or_update_lambda(name, image_uri, self._role_arn)
+        self._configure_trigger(name, **kwargs)
 
         print(settings.INFO_ALERT, "Done.")
 
-    def _create_or_update(self, name: str, image_uri: str, role_arn: str):
+    def _create_or_update_lambda(
+        self, name: str, image_uri: str, role_arn: str
+    ):
         """Create or update Lambda function."""
         try:
             self._lambda.get_function(FunctionName=name)
             print("  Updating Lambda function...")
             self._lambda.update_function_code(
-                FunctionName=name,
-                ImageUri=image_uri,
+                FunctionName=name, ImageUri=image_uri
             )
         except self._lambda.exceptions.ResourceNotFoundException:
             print("  Creating Lambda function...")
@@ -81,37 +92,5 @@ class LambdaDeployer(Deployer):
                 MemorySize=512,
             )
 
-    def _create_schedule(self, name: str, schedule: str):
-        """Create EventBridge schedule rule for Lambda."""
-        rule_name = f"{name}-schedule"
-        function_arn = (
-            f"arn:aws:lambda:{self._region}:{self._account_id}:function:{name}"
-        )
-
-        print(f"  Creating EventBridge rule '{rule_name}'...")
-        self._events.put_rule(
-            Name=rule_name,
-            ScheduleExpression=schedule,
-            State="ENABLED",
-        )
-
-        with contextlib.suppress(
-            self._lambda.exceptions.ResourceConflictException
-        ):
-            self._lambda.add_permission(
-                FunctionName=name,
-                StatementId=rule_name,
-                Action="lambda:InvokeFunction",
-                Principal="events.amazonaws.com",
-                SourceArn=(
-                    f"arn:aws:events:{self._region}:{self._account_id}"
-                    f":rule/{rule_name}"
-                ),
-            )
-
-        self._events.put_targets(
-            Rule=rule_name,
-            Targets=[{"Id": "1", "Arn": function_arn}],
-        )
-
-        print(f"  Schedule: {schedule}")
+    def _configure_trigger(self, name: str, **kwargs) -> None:
+        """Override in subclasses to configure the specific trigger."""

dotflow-0.15.0.dev2/dotflow/cloud/aws/lambda_api_deployer.py

@@ -0,0 +1,67 @@
+"""Lambda + API Gateway deployment."""
+
+from __future__ import annotations
+
+import contextlib
+
+from dotflow.cloud.aws.base_lambda_deployer import BaseLambdaDeployer
+
+
+class LambdaApiDeployer(BaseLambdaDeployer):
+    """Deploy dotflow pipeline as Lambda + API Gateway."""
+
+    def _configure_trigger(self, name: str, **kwargs) -> None:
+        """Create HTTP API with Lambda integration."""
+        apigw = self._boto3.client("apigatewayv2", region_name=self._region)
+        api_name = f"{name}-api"
+
+        api_id = self._find_api(apigw, api_name)
+
+        if not api_id:
+            print("  Creating API Gateway...")
+            response = apigw.create_api(Name=api_name, ProtocolType="HTTP")
+            api_id = response["ApiId"]
+
+            integration = apigw.create_integration(
+                ApiId=api_id,
+                IntegrationType="AWS_PROXY",
+                IntegrationUri=self._function_arn,
+                PayloadFormatVersion="2.0",
+            )
+
+            apigw.create_route(
+                ApiId=api_id,
+                RouteKey="POST /workflow",
+                Target=f"integrations/{integration['IntegrationId']}",
+            )
+
+            apigw.create_stage(
+                ApiId=api_id, StageName="$default", AutoDeploy=True
+            )
+
+            with contextlib.suppress(
+                self._lambda.exceptions.ResourceConflictException
+            ):
+                self._lambda.add_permission(
+                    FunctionName=name,
+                    StatementId=f"{api_name}-invoke",
+                    Action="lambda:InvokeFunction",
+                    Principal="apigateway.amazonaws.com",
+                    SourceArn=(
+                        f"arn:aws:execute-api:{self._region}:"
+                        f"{self._account_id}:{api_id}/*"
+                    ),
+                )
+
+        url = (
+            f"https://{api_id}.execute-api."
+            f"{self._region}.amazonaws.com/workflow"
+        )
+        print(f"  Endpoint: {url}")
+
+    def _find_api(self, apigw, name: str) -> str | None:
+        """Find existing API by name."""
+        for api in apigw.get_apis().get("Items", []):
+            if api["Name"] == name:
+                return api["ApiId"]
+        return None

dotflow-0.15.0.dev2/dotflow/cloud/aws/lambda_deployer.py

@@ -0,0 +1,49 @@
+"""Lambda deployment."""
+
+from __future__ import annotations
+
+import contextlib
+
+from dotflow.cloud.aws.base_lambda_deployer import BaseLambdaDeployer
+
+
+class LambdaDeployer(BaseLambdaDeployer):
+    """Deploy dotflow pipelines to AWS Lambda."""
+
+    def _configure_trigger(self, name: str, **kwargs) -> None:
+        """Create EventBridge schedule if provided."""
+        schedule = kwargs.get("schedule")
+        if not schedule:
+            return
+
+        rule_name = f"{name}-schedule"
+
+        print(f"  Creating EventBridge rule '{rule_name}'...")
+        events = self._boto3.client("events", region_name=self._region)
+
+        events.put_rule(
+            Name=rule_name,
+            ScheduleExpression=schedule,
+            State="ENABLED",
+        )
+
+        with contextlib.suppress(
+            self._lambda.exceptions.ResourceConflictException
+        ):
+            self._lambda.add_permission(
+                FunctionName=name,
+                StatementId=rule_name,
+                Action="lambda:InvokeFunction",
+                Principal="events.amazonaws.com",
+                SourceArn=(
+                    f"arn:aws:events:{self._region}:{self._account_id}"
+                    f":rule/{rule_name}"
+                ),
+            )
+
+        events.put_targets(
+            Rule=rule_name,
+            Targets=[{"Id": "1", "Arn": self._function_arn}],
+        )
+
+        print(f"  Schedule: {schedule}")

dotflow-0.15.0.dev2/dotflow/cloud/aws/lambda_s3_deployer.py

@@ -0,0 +1,56 @@
+"""Lambda + S3 Trigger deployment."""
+
+from __future__ import annotations
+
+import contextlib
+
+from dotflow.cloud.aws.base_lambda_deployer import BaseLambdaDeployer
+
+
+class LambdaS3Deployer(BaseLambdaDeployer):
+    """Deploy dotflow pipeline as Lambda + S3 Trigger."""
+
+    def _configure_trigger(self, name: str, **kwargs) -> None:
+        """Create S3 bucket with Lambda notification."""
+        s3 = self._boto3.client("s3", region_name=self._region)
+        bucket_name = f"{name}-source"
+
+        print(f"  Creating S3 bucket '{bucket_name}'...")
+        try:
+            if self._region == "us-east-1":
+                s3.create_bucket(Bucket=bucket_name)
+            else:
+                s3.create_bucket(
+                    Bucket=bucket_name,
+                    CreateBucketConfiguration={
+                        "LocationConstraint": self._region
+                    },
+                )
+        except s3.exceptions.BucketAlreadyOwnedByYou:
+            pass
+
+        with contextlib.suppress(
+            self._lambda.exceptions.ResourceConflictException
+        ):
+            self._lambda.add_permission(
+                FunctionName=name,
+                StatementId=f"{name}-s3-invoke",
+                Action="lambda:InvokeFunction",
+                Principal="s3.amazonaws.com",
+                SourceArn=f"arn:aws:s3:::{bucket_name}",
+            )
+
+        print("  Configuring S3 notification...")
+        s3.put_bucket_notification_configuration(
+            Bucket=bucket_name,
+            NotificationConfiguration={
+                "LambdaFunctionConfigurations": [
+                    {
+                        "LambdaFunctionArn": self._function_arn,
+                        "Events": ["s3:ObjectCreated:*"],
+                    }
+                ]
+            },
+        )
+
+        print(f"  Trigger: s3://{bucket_name}/*")

dotflow-0.15.0.dev2/dotflow/cloud/aws/lambda_sqs_deployer.py

@@ -0,0 +1,43 @@
+"""Lambda + SQS Trigger deployment."""
+
+from __future__ import annotations
+
+from dotflow.cloud.aws.base_lambda_deployer import BaseLambdaDeployer
+
+
+class LambdaSQSDeployer(BaseLambdaDeployer):
+    """Deploy dotflow pipeline as Lambda + SQS Trigger."""
+
+    def _configure_trigger(self, name: str, **kwargs) -> None:
+        """Create SQS queue and event source mapping."""
+        sqs = self._boto3.client("sqs", region_name=self._region)
+        queue_name = f"{name}-queue"
+
+        print(f"  Creating SQS queue '{queue_name}'...")
+        try:
+            response = sqs.create_queue(
+                QueueName=queue_name,
+                Attributes={"VisibilityTimeout": "960"},
+            )
+            queue_url = response["QueueUrl"]
+        except sqs.exceptions.QueueNameAlreadyExists:
+            queue_url = sqs.get_queue_url(QueueName=queue_name)["QueueUrl"]
+
+        queue_arn = sqs.get_queue_attributes(
+            QueueUrl=queue_url, AttributeNames=["QueueArn"]
+        )["Attributes"]["QueueArn"]
+
+        existing = self._lambda.list_event_source_mappings(
+            FunctionName=name, EventSourceArn=queue_arn
+        )["EventSourceMappings"]
+
+        if not existing:
+            print("  Creating event source mapping...")
+            self._lambda.create_event_source_mapping(
+                FunctionName=name,
+                EventSourceArn=queue_arn,
+                BatchSize=1,
+                Enabled=True,
+            )
+
+        print(f"  Queue: {queue_url}")

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/dotflow/cloud/core.py

@@ -45,6 +45,28 @@ class ObjectStorage(ABC):
         """Write data to a key."""
 
 
+class Queue(ABC):
+    """Base class for message queues (SQS, Pub/Sub, Azure Queue, etc.)."""
+
+    @abstractmethod
+    def create(self, name: str) -> str:
+        """Create queue. Returns queue URL/ID."""
+
+    @abstractmethod
+    def get_arn(self, name: str) -> str:
+        """Get queue ARN/ID."""
+
+
+class EventScheduler(ABC):
+    """Base class for event schedulers (EventBridge, Cloud Scheduler, etc.)."""
+
+    @abstractmethod
+    def create_schedule(
+        self, name: str, expression: str, target_arn: str
+    ) -> None:
+        """Create a scheduled rule targeting a resource."""
+
+
 class Deployer(ABC):
     """Base class for all cloud deployers."""
 

dotflow-0.15.0.dev2/dotflow/cloud/github/__init__.py

@@ -0,0 +1,5 @@
+"""GitHub cloud module."""
+
+from dotflow.cloud.github.actions_deployer import ActionsDeployer
+
+__all__ = ["ActionsDeployer"]

dotflow-0.15.0.dev2/dotflow/cloud/github/actions_deployer.py

@@ -0,0 +1,113 @@
+"""GitHub Actions deployment."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from rich import print  # type: ignore
+
+from dotflow.cloud.core import Deployer
+from dotflow.cloud.github.constants import PYGITHUB_NOT_FOUND, TOKEN_NOT_FOUND
+from dotflow.settings import Settings as settings
+
+
+class ActionsDeployer(Deployer):
+    """Deploy dotflow pipeline to GitHub Actions."""
+
+    def __init__(self, token: str = None):
+        try:
+            from github import Github, GithubException
+        except ImportError as err:
+            raise SystemExit(PYGITHUB_NOT_FOUND) from err
+
+        self._token = token or os.environ.get("GITHUB_TOKEN")
+        if not self._token:
+            raise SystemExit(TOKEN_NOT_FOUND)
+
+        self._github = Github(self._token)
+        self._GithubException = GithubException
+        self._user = self._github.get_user()
+
+    def setup(self, name: str) -> None:
+        """No-op — GitHub manages everything."""
+
+    def ensure_roles(self, name: str) -> str:
+        """No-op."""
+        return ""
+
+    def ensure_logs(self, name: str) -> None:
+        """No-op."""
+
+    def deploy(self, name: str, **kwargs) -> None:
+        """Create repo and push all project files."""
+        print(settings.INFO_ALERT, f"Deploying to GitHub Actions '{name}'...")
+
+        repo = self._create_or_get_repo(name)
+        self._push_files(repo)
+
+        print(f"  Repository: {repo.html_url}")
+        print(f"  Actions: {repo.html_url}/actions")
+        print(settings.INFO_ALERT, "Done.")
+
+    def _create_or_get_repo(self, name: str):
+        """Create repo or get existing."""
+        try:
+            repo = self._user.get_repo(name)
+            print(f"  Using existing repo '{name}'")
+            return repo
+        except self._GithubException:
+            pass
+
+        print(f"  Creating repo '{name}'...")
+        return self._user.create_repo(
+            name=name,
+            private=True,
+            auto_init=False,
+        )
+
+    def _push_files(self, repo):
+        """Push all project files to the repo."""
+        print("  Pushing files...")
+
+        project_dir = Path.cwd()
+        count = 0
+
+        for filepath in sorted(project_dir.rglob("*")):
+            if not filepath.is_file():
+                continue
+
+            relative = str(filepath.relative_to(project_dir))
+
+            if relative.startswith(".") and not relative.startswith(".github"):
+                continue
+
+            if "__pycache__" in relative or ".egg-info" in relative:
+                continue
+
+            try:
+                content = filepath.read_text()
+            except UnicodeDecodeError:
+                continue
+
+            self._create_or_update_file(repo, relative, content)
+            count += 1
+
+        print(f"  Pushed {count} files")
+
+    def _create_or_update_file(self, repo, path: str, content: str):
+        """Create or update a single file in the repo."""
+        try:
+            existing = repo.get_contents(path)
+            repo.update_file(
+                path=path,
+                message=f"update {path}",
+                content=content,
+                sha=existing.sha,
+            )
+        except self._GithubException:
+            repo.create_file(
+                path=path,
+                message=f"add {path}",
+                content=content,
+            )

dotflow-0.15.0.dev2/dotflow/cloud/github/constants.py

@@ -0,0 +1,8 @@
+"""GitHub constants."""
+
+PYGITHUB_NOT_FOUND = "PyGithub is required: pip install dotflow[deploy-github]"
+
+TOKEN_NOT_FOUND = (
+    "GitHub token not found. "
+    "Set GITHUB_TOKEN environment variable or pass --token."
+)

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/dotflow/providers/__init__.py

@@ -13,6 +13,7 @@ from dotflow.providers.tracer_default import TracerDefault
 __all__ = [
     "LogDefault",
     "LogOpenTelemetry",
+    "LogSentry",
     "NotifyDefault",
     "NotifyDiscord",
     "NotifyTelegram",
@@ -26,6 +27,7 @@ __all__ = [
     "MetricsOpenTelemetry",
     "TracerDefault",
     "TracerOpenTelemetry",
+    "TracerSentry",
 ]
 
 
@@ -62,4 +64,14 @@ def __getattr__(name):
 
         return LogOpenTelemetry
 
+    if name == "LogSentry":
+        from dotflow.providers.log_sentry import LogSentry
+
+        return LogSentry
+
+    if name == "TracerSentry":
+        from dotflow.providers.tracer_sentry import TracerSentry
+
+        return TracerSentry
+
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

dotflow-0.15.0.dev2/dotflow/providers/log_sentry.py

@@ -0,0 +1,96 @@
+"""Log Sentry"""
+
+from __future__ import annotations
+
+from dotflow.abc.log import Log
+from dotflow.core.exception import ModuleNotFound
+
+
+class LogSentry(Log):
+    """
+    Import:
+        You can import the **LogSentry** class with:
+
+            from dotflow.providers import LogSentry
+
+    Example:
+        `class` dotflow.providers.log_sentry.LogSentry
+
+            from dotflow import Config, DotFlow
+            from dotflow.providers import LogSentry
+
+            config = Config(
+                log=LogSentry(
+                    dsn="https://xxx@sentry.io/123",
+                    environment="production",
+                ),
+            )
+
+            workflow = DotFlow(config=config)
+
+    Args:
+        dsn (str): Sentry DSN for the project.
+        environment (str): Environment tag sent to Sentry.
+            Defaults to None.
+        traces_sample_rate (float): Sample rate for performance traces (0.0 to 1.0).
+            Defaults to 0.0.
+    """
+
+    def __init__(
+        self,
+        dsn: str,
+        environment: str | None = None,
+        traces_sample_rate: float = 0.0,
+    ) -> None:
+        try:
+            import sentry_sdk
+        except ImportError as err:
+            raise ModuleNotFound(
+                module="sentry-sdk", library="dotflow[sentry]"
+            ) from err
+
+        sentry_sdk.init(
+            dsn=dsn,
+            environment=environment,
+            traces_sample_rate=traces_sample_rate,
+        )
+        self._sentry = sentry_sdk
+
+    def info(self, **kwargs) -> None:
+        task = kwargs.get("task")
+        if task:
+            self._sentry.add_breadcrumb(
+                category="dotflow",
+                message=f"task:{task.task_id} {task.status}",
+                level="info",
+            )
+
+    def error(self, **kwargs) -> None:
+        task = kwargs.get("task")
+        if not task or not task.errors:
+            return
+
+        last_error = task.errors[-1]
+        self._sentry.capture_message(
+            f"Task {task.task_id} failed: {last_error.message}",
+            level="error",
+            extras={
+                "workflow_id": str(task.workflow_id),
+                "task_id": str(task.task_id),
+                "exception": str(last_error.exception),
+                "attempt": last_error.attempt,
+                "traceback": last_error.traceback,
+            },
+        )
+
+    def warning(self, **kwargs) -> None:
+        task = kwargs.get("task")
+        if task:
+            self._sentry.add_breadcrumb(
+                category="dotflow",
+                message=f"task:{task.task_id} {task.status}",
+                level="warning",
+            )
+
+    def debug(self, **kwargs) -> None:
+        pass

dotflow-0.15.0.dev2/dotflow/providers/tracer_sentry.py

@@ -0,0 +1,126 @@
+"""Tracer Sentry"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dotflow.abc.tracer import Tracer
+from dotflow.core.exception import ModuleNotFound
+
+
+class TracerSentry(Tracer):
+    """
+    Import:
+        You can import the **TracerSentry** class with:
+
+            from dotflow.providers import TracerSentry
+
+    Example:
+        `class` dotflow.providers.tracer_sentry.TracerSentry
+
+            from dotflow import Config, DotFlow
+            from dotflow.providers import TracerSentry
+
+            config = Config(
+                tracer=TracerSentry(),
+            )
+
+            workflow = DotFlow(config=config)
+
+    Args:
+        dsn (str): Sentry DSN for the project. If None, uses the SDK
+            already initialized by LogSentry or manually.
+        environment (str): Environment tag sent to Sentry.
+            Defaults to None.
+        traces_sample_rate (float): Sample rate for performance traces (0.0 to 1.0).
+            Defaults to 1.0.
+    """
+
+    def __init__(
+        self,
+        dsn: str | None = None,
+        environment: str | None = None,
+        traces_sample_rate: float = 1.0,
+    ) -> None:
+        try:
+            import sentry_sdk
+        except ImportError as err:
+            raise ModuleNotFound(
+                module="sentry-sdk", library="dotflow[sentry]"
+            ) from err
+
+        if dsn:
+            sentry_sdk.init(
+                dsn=dsn,
+                environment=environment,
+                traces_sample_rate=traces_sample_rate,
+            )
+
+        self._sentry = sentry_sdk
+        self._transactions: dict[str, Any] = {}
+        self._spans: dict[str, Any] = {}
+
+    def start_workflow(self, workflow_id: Any, **kwargs) -> None:
+        key = str(workflow_id)
+        transaction = self._sentry.start_transaction(
+            op="workflow",
+            name=f"workflow:{key}",
+        )
+        transaction.set_tag("dotflow.workflow_id", key)
+
+        for k, v in kwargs.items():
+            transaction.set_tag(f"dotflow.{k}", str(v))
+
+        self._transactions[key] = transaction
+
+    def end_workflow(self, workflow_id: Any, **kwargs) -> None:
+        key = str(workflow_id)
+        transaction = self._transactions.pop(key, None)
+        if not transaction:
+            return
+
+        failed = kwargs.get("failed", False)
+        transaction.set_status("internal_error" if failed else "ok")
+
+        if "duration" in kwargs:
+            transaction.set_data("dotflow.duration", kwargs["duration"])
+
+        transaction.finish()
+
+    def start_task(self, task: Any) -> None:
+        workflow_key = str(task.workflow_id)
+        task_key = f"{workflow_key}:{task.task_id}"
+
+        transaction = self._transactions.get(workflow_key)
+        if not transaction:
+            return
+
+        span = transaction.start_child(
+            op="task",
+            name=f"task:{task.task_id}",
+        )
+        span.set_tag("dotflow.workflow_id", workflow_key)
+        span.set_tag("dotflow.task_id", str(task.task_id))
+        self._spans[task_key] = span
+
+    def end_task(self, task: Any) -> None:
+        task_key = f"{task.workflow_id}:{task.task_id}"
+        span = self._spans.pop(task_key, None)
+        if not span:
+            return
+
+        span.set_tag("dotflow.task.status", str(task.status))
+
+        if task.duration is not None:
+            span.set_data("dotflow.task.duration", task.duration)
+        if task.retry_count:
+            span.set_data("dotflow.task.retry_count", task.retry_count)
+
+        if task.errors:
+            last_error = task.errors[-1]
+            span.set_data("dotflow.task.exception", str(last_error.exception))
+            span.set_status("internal_error")
+        else:
+            span.set_status("ok")
+
+        span.finish()

{dotflow-0.15.0.dev1 → dotflow-0.15.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.15.0.dev1"
+version = "0.15.0.dev2"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -58,12 +58,14 @@ aws = ["boto3"]
 gcp = ["google-cloud-storage"]
 deploy-aws = ["boto3"]
 deploy-gcp = ["google-cloud-run", "google-cloud-build", "google-cloud-artifact-registry", "google-cloud-service-usage", "google-cloud-storage", "google-auth"]
+deploy-github = ["PyGithub"]
 scheduler = ["croniter"]
 otel = ["opentelemetry-api", "opentelemetry-sdk"]
+sentry = ["sentry-sdk"]
 
 [tool.poetry]
 name = "dotflow"
-version = "0.15.0.dev1"
+version = "0.15.0.dev2"
 description = "🎲 Dotflow turns an idea into flow! Lightweight Python library for execution pipelines with retry, parallel, cron and async support."
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"

dotflow-0.15.0.dev1/dotflow/cloud/aws/__init__.py

@@ -1,6 +0,0 @@
-"""AWS deploy module."""
-
-from dotflow.cloud.aws.ecs_deployer import ECSDeployer
-from dotflow.cloud.aws.lambda_deployer import LambdaDeployer
-
-__all__ = ["LambdaDeployer", "ECSDeployer"]