aws-python-helper 1.8.0__tar.gz → 1.9.0__tar.gz

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-python-helper
-Version: 1.8.0
+Version: 1.9.0
 Summary: AWS Python Helper Framework
 Author-email: Fabian Claros <neufabiae@gmail.com>
 License-Expression: MIT

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/aws_python_helper/__init__.py

@@ -57,11 +57,12 @@ from .invoker import (
 )
 
 
-from .monitoring import process_run, RunReporter, ProcessRunPublisher
+from .monitoring import process_run, resolve_code, RunReporter, ProcessRunPublisher
 
 __all__ = [
     'API',
     'process_run',
+    'resolve_code',
     'RunReporter',
     'ProcessRunPublisher',
     'SQSConsumer',

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/aws_python_helper/context/state_validator.py

@@ -11,6 +11,11 @@ class StateValidator:
     """
     Validates that a state exists and is active in the core.states collection.
 
+    A state counts as active with either `status: "active"` or `is_active: True`.
+    The boolean is what every service has written until now; the status is what
+    the region catalog replicates. Accepting both means the boolean can be
+    dropped once no service reads it, without a flag day.
+
     Uses an in-memory cache with a 5-minute TTL to avoid querying the database
     on every request. Only valid (active) states are cached — invalid states
     always hit the database so that recently activated states are picked up
@@ -23,7 +28,7 @@ class StateValidator:
     @classmethod
     async def validate(cls, state: str):
         """
-        Validate that state exists in core.states with is_active=True.
+        Validate that state exists in core.states and is active.
 
         Args:
             state: The state name to validate
@@ -40,7 +45,10 @@ class StateValidator:
 
         from ..database.mongo_manager import MongoManager
         db = MongoManager.get_database('core')
-        doc = await db.states.find_one({"name": state, "is_active": True})
+        doc = await db.states.find_one({
+            "name": state,
+            "$or": [{"status": "active"}, {"is_active": True}],
+        })
 
         if doc:
             cls._cache[state] = now

aws_python_helper-1.9.0/aws_python_helper/monitoring/__init__.py

@@ -0,0 +1,3 @@
+from .run import ProcessRunPublisher, RunReporter, process_run, resolve_code
+
+__all__ = ['process_run', 'resolve_code', 'RunReporter', 'ProcessRunPublisher']

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/aws_python_helper/monitoring/run.py

@@ -4,10 +4,21 @@ Two hand-written publishes would work, and the second one would get forgotten on
 the path that matters: the failure. So the boundary is a context manager — enter
 and it says it started, leave and it says how it went, exception included.
 
-Nothing here can raise into the caller. Monitoring must never be able to break
-the thing it monitors: a topic that does not exist, credentials that are wrong,
-SNS being slow are all reasons to lose a record, never reasons to fail a run that
-otherwise worked.
+The process code is the name of the AWS resource doing the work, taken from the
+environment. Nobody types it twice: a code invented here and typed again in the
+panel is a code that will not match one day, and a mismatch is silent — the runs
+arrive, core finds no process, and nothing is recorded. Taking it from the
+environment means the panel can offer the real resource list and the two sides
+cannot drift.
+
+Nothing here decides whether a run is kept. It publishes; core has the database
+and filters. Wrapping something in `process_run` is not turning monitoring on —
+registering the process in the panel is.
+
+Nothing here can raise into the caller either. Monitoring must never be able to
+break the thing it monitors: a topic that does not exist, credentials that are
+wrong, SNS being slow are all reasons to lose a record, never reasons to fail a
+run that otherwise worked.
 """
 
 import logging
@@ -17,6 +28,7 @@ from contextlib import asynccontextmanager
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
+from ..context.session import get_session
 from ..sns.publisher import SNSPublisher
 
 logger = logging.getLogger(__name__)
@@ -28,6 +40,11 @@ FAILED = "failed"
 
 TOPIC_ENV = "PROCESS_RUNS_TOPIC_ARN"
 
+# De dónde sale el código del proceso, en orden. `PROCESS_CODE` es para lo que no
+# es una lambda —una tarea de Fargate lo recibe en su definición— y el nombre de
+# la función es lo que AWS deja puesto solo.
+CODE_ENVS = ("PROCESS_CODE", "AWS_LAMBDA_FUNCTION_NAME")
+
 
 class ProcessRunPublisher(SNSPublisher):
     pass
@@ -81,12 +98,25 @@ def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def resolve_code(explicit: Optional[str] = None) -> Optional[str]:
+    """El código del proceso: el nombre del recurso que está corriendo."""
+    if explicit:
+        return explicit
+    for name in CODE_ENVS:
+        value = (os.getenv(name) or "").strip()
+        if value:
+            return value
+    return None
+
+
 @asynccontextmanager
 async def process_run(
-    process_code: str,
+    process_code: Optional[str] = None,
     *,
     run_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
     scope: Optional[str] = None,
+    state: Optional[str] = None,
     resource_arn: Optional[str] = None,
     request_id: Optional[str] = None,
 ):
@@ -101,47 +131,65 @@ async def process_run(
     se está vigilando, y registrarlo solo llenaría la pantalla de ejecuciones que
     nadie puede configurar.
     """
-    reporter = RunReporter(run_id or str(uuid.uuid4()), process_code)
+    code = resolve_code(process_code)
+    if not code:
+        # Sin código no hay a qué proceso pertenecer. Se sigue adelante sin
+        # reportar: el trabajo importa más que su registro.
+        logger.warning(
+            "No process code: pass one, or set %s. The run was not reported",
+            " or ".join(CODE_ENVS),
+        )
+        yield RunReporter("", "")
+        return
+
+    # El estado sale de la sesión: core identifica un proceso por código *y*
+    # estado, porque una misma lambda corre para varios con frecuencias
+    # distintas.
+    if state is None:
+        session = get_session()
+        state = session.state if session else None
+
+    reporter = RunReporter(run_id or str(uuid.uuid4()), code)
     started_at = _now()
+    common = {
+        "run_id": reporter.run_id,
+        "process_code": code,
+        "state": state,
+        "parent_run_id": parent_run_id,
+        "request_id": request_id,
+    }
 
     await _publish({
-        "run_id": reporter.run_id,
-        "process_code": process_code,
+        **common,
         "status": LAUNCHED,
         "started_at": started_at,
         "scope": scope,
-        # Lo único que AWS deja en el ambiente. El ARN completo y el id de la
-        # invocación viven en el `context` del handler, que acá no se tiene: quien
-        # lo tenga los pasa por `resource_arn` y `request_id`.
-        "resource_arn": resource_arn or os.getenv("AWS_LAMBDA_FUNCTION_NAME") or None,
-        "request_id": request_id,
+        # El ARN completo y el id de la invocación viven en el `context` del
+        # handler, que acá no se tiene: quien lo tenga los pasa por parámetro.
+        "resource_arn": resource_arn,
     })
 
     try:
         yield reporter
     except Exception as error:
         await _publish({
-            "run_id": reporter.run_id,
-            "process_code": process_code,
+            **common,
             "status": FAILED,
             "started_at": started_at,
             "finished_at": _now(),
             "error": f"{type(error).__name__}: {error}"[:2000],
             "counters": reporter.counters,
             "scope": reporter.scope or scope,
-            "request_id": request_id,
         })
         # La excepción sigue su camino: el monitoreo anota lo que pasó, no lo
         # decide. Tragarla acá convertiría una falla en un éxito silencioso.
         raise
     else:
         await _publish({
-            "run_id": reporter.run_id,
-            "process_code": process_code,
+            **common,
             "status": SUCCESS,
             "started_at": started_at,
             "finished_at": _now(),
             "counters": reporter.counters,
             "scope": reporter.scope or scope,
-            "request_id": request_id,
         })

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/aws_python_helper/sns/publisher.py

@@ -15,6 +15,11 @@ from abc import ABC
 from ..context.session import get_session
 
 
+# Lo que SNS acepta en una sola llamada a PublishBatch. No es configurable: es
+# un límite del servicio, y pasarse falla el lote entero sin publicar nada.
+MAX_BATCH_ENTRIES = 10
+
+
 class SNSPublisher(ABC):
     """
     Base class to publish messages to SNS
@@ -172,35 +177,52 @@ class SNSPublisher(ABC):
         message_ids_success = []
         message_ids_failed = []
 
-        params = {
-            'TopicArn': self.topic_arn
-        }
-        
         for i, message in enumerate(messages):
             try:
                 message_to_publish.append(self._format_message(message, i))
             except Exception as e:
                 self.logger.error(f"Error publishing message {i} in batch: {e}")
+                message_ids_failed.append(None)
                 # Continue with the other messages
                 continue
 
-        params['PublishBatchRequestEntries'] = message_to_publish
+        # De a diez, que es lo que SNS acepta por llamada. Mandar más falla el
+        # lote entero sin publicar nada, así que una lista larga no se pierde a
+        # medias: se pierde completa.
+        for start in range(0, len(message_to_publish), MAX_BATCH_ENTRIES):
+            chunk = message_to_publish[start:start + MAX_BATCH_ENTRIES]
 
-        try:
-            result = self.sns_client.publish_batch(**params)
-        except Exception as e:
-            self.logger.error(f"Error calling publish_batch to {self.topic_arn}: {e}")
-            raise
+            # El Id sólo tiene que ser único dentro de su propia llamada.
+            entries = [
+                {**entry, 'Id': str(position)}
+                for position, entry in enumerate(chunk)
+            ]
+
+            try:
+                result = self.sns_client.publish_batch(
+                    TopicArn=self.topic_arn,
+                    PublishBatchRequestEntries=entries,
+                )
+            except Exception as e:
+                # Se sigue con los demás lotes: cortar acá dejaría sin publicar
+                # todo lo que venía detrás por un problema que puede ser de este
+                # lote solo.
+                self.logger.error(
+                    f"Error calling publish_batch to {self.topic_arn} "
+                    f"({start}-{start + len(chunk) - 1} of {len(message_to_publish)}): {e}"
+                )
+                message_ids_failed.extend([None] * len(chunk))
+                continue
 
-        for message in result.get('Successful', []):
-            message_ids_success.append(message['MessageId'])
+            for message in result.get('Successful', []):
+                message_ids_success.append(message['MessageId'])
 
-        for message in result.get('Failed', []):
-            self.logger.error(
-                f"Failed to publish message {message.get('Id')} to {self.topic_arn}: "
-                f"Code={message.get('Code')}, Message={message.get('Message')}"
-            )
-            message_ids_failed.append(None)
+            for message in result.get('Failed', []):
+                self.logger.error(
+                    f"Failed to publish message {message.get('Id')} to {self.topic_arn}: "
+                    f"Code={message.get('Code')}, Message={message.get('Message')}"
+                )
+                message_ids_failed.append(None)
 
         self.logger.info(
             f"Batch publish to {self.topic_arn}: "

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/aws_python_helper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-python-helper
-Version: 1.8.0
+Version: 1.9.0
 Summary: AWS Python Helper Framework
 Author-email: Fabian Claros <neufabiae@gmail.com>
 License-Expression: MIT

{aws_python_helper-1.8.0 → aws_python_helper-1.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aws-python-helper"
-version = "1.8.0"
+version = "1.9.0"
 description = "AWS Python Helper Framework"
 readme = "README.md"
 requires-python = ">=3.9"

aws_python_helper-1.8.0/aws_python_helper/monitoring/__init__.py

@@ -1,3 +0,0 @@
-from .run import ProcessRunPublisher, RunReporter, process_run
-
-__all__ = ['process_run', 'RunReporter', 'ProcessRunPublisher']