django-lambda-tasks 0.6.5__tar.gz → 0.6.7__tar.gz

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/.kiro/steering/product.md

@@ -151,7 +151,7 @@ class SQSLambdaTaskMessage(BaseModel):
 - A module-level `_cold_start_done` sentinel ensures the sequence runs only once; subsequent warm invocations skip it
 - Both loaders run unconditionally (outside the `DJANGO_SETTINGS_MODULE` check) — the environment secret may provide that var, and individual secrets may depend on environment-loaded vars
 - A temporary `StreamHandler` is attached to the `lambda_tasks` logger for the duration of the loaders so their log output is visible before Django's `LOGGING` dictConfig has run; it is removed immediately after so that Django's configuration is the sole authority on logging from that point on
-- `resource.setrlimit(RLIMIT_DATA)` is set from `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` so that excessive allocation raises `MemoryError` instead of triggering the OOM killer
+- `resource.setrlimit(RLIMIT_AS)` is set from `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` (Lambda) or the ECS task metadata endpoint (Fargate/Batch) so that excessive allocation raises `MemoryError` instead of triggering the OOM killer
 
 `main()` in `handler.py` — AWS Batch container entry point (`python -m lambda_tasks.handler`):
 - Reads `LAMBDA_TASKS_MESSAGE` env var (the serialized task JSON, set by `submit_batch_job` via container overrides)
@@ -215,11 +215,25 @@ Statuses: `RUNNING`, `SUCCESS`, `FAILED`, `RETRYING`
 | `LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT` | `300` | Hard timeout in seconds |
 | `LAMBDA_TASKS_EAGER` | `False` | Run tasks synchronously in-process (no SQS) |
 | `LAMBDA_TASKS_LOCAL_WORKERS` | `0` | Number of worker processes for async local execution (development only; mutually exclusive with `EAGER`) |
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `False` | Drop all tasks silently (for local tests; mutually exclusive with `EAGER` and `LOCAL_WORKERS`) |
 | `LAMBDA_TASKS_MAX_RETRIES` | `2880` | Maximum retry attempts before `MaxRetriesExceededError` is raised (60 × 24 × 2) |
 | `LAMBDA_TASKS_SINGLETON_CACHE` | `"default"` | Django cache backend used for singleton task locks |
 
 `LAMBDA_TASKS_QUEUES` must be set and include a `"default"` key. The `"default"` queue must be an SQS queue. Both timeout values must be greater than zero and `soft_timeout` must always be strictly less than `hard_timeout`. The maximum allowed timeout depends on the queue type: 900 for SQS, 3600 for Batch.
 
+## Noop Execution Mode
+
+Set `LAMBDA_TASKS_NOOP_EXECUTION = True` to silently drop all tasks. Useful for local tests where task execution is irrelevant. When a task is dispatched, a warning is logged with the task name, kwargs, and queue, and execution returns immediately — no SQS message is sent, no task is executed.
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+`LAMBDA_TASKS_NOOP_EXECUTION` can only be set when `LAMBDA_TASKS_EAGER` is `False` and `LAMBDA_TASKS_LOCAL_WORKERS` is `0`. Setting it alongside either raises `ImproperlyConfigured`.
+
+A Django deployment check (`lambda_tasks.W001`) warns if this setting is enabled, ensuring it is not accidentally left on in production.
+
 ## Eager Mode
 
 Set `LAMBDA_TASKS_EAGER = True` to run tasks synchronously in-process (no SQS). Useful for local development and tests.
@@ -238,12 +252,15 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 ```
 
 The execution mode hierarchy is:
-1. **Eager mode** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local mode** (`LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS mode** (default) — async, Lambda workers, timeouts enforced
+1. **Noop mode** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager mode** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local mode** (`LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS mode** (default) — async, Lambda workers, timeouts enforced
 
 `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`. A negative value also raises `ImproperlyConfigured`.
 
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS`.
+
 Key behaviours:
 - The process pool is created lazily on first task submission and reused for the server lifetime
 - Each worker process calls `django.setup()` once via the pool initializer
@@ -267,6 +284,18 @@ Relying on `atexit` alone loses this race in applications with a heavy shutdown
 
 `_shutdown_pool()` does **not** use `pool.shutdown(wait=True)`. `wait=True` blocks on joining the worker processes, and a worker that ran a heavy `django.setup()` is slow to exit — `concurrent.futures` does not unlink the pool's queue semaphores until the workers actually die, so the parent's near-instant `SIGKILL` still wins and the semaphores leak. Instead `_shutdown_pool()` **terminates the worker processes first** (a near-instant signal to children we own), then calls `pool.shutdown(wait=False, cancel_futures=True)`. With the workers already gone, the queue semaphores are unlinked in milliseconds — fast enough to beat the parent's `SIGKILL`.
 
+## Deployment Checks
+
+`lambda_tasks.checks` registers a Django deployment check (runs with `manage.py check --deploy`) that warns if any non-production execution mode is enabled:
+
+| ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+The checks are registered via `AppConfig.ready()` and tagged with `deploy=True` so they only fire during `--deploy` checks.
+
 ## Logging
 
 Import `task_logger` to emit log records that are automatically prefixed with the active `message_id`:

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/.kiro/steering/structure.md

@@ -12,6 +12,7 @@ django-lambda-tasks/
 │   ├── __init__.py
 │   ├── admin.py                # Django admin for TaskRecord
 │   ├── apps.py                 # Django AppConfig
+│   ├── checks.py               # Django deployment checks (noop, eager, local_workers)
 │   ├── decorators.py           # LambdaTaskWrapper, @lambda_task
 │   ├── handler.py              # AWS Lambda entry point + AWS Batch container entry point (main)
 │   ├── logging.py              # task_logger — invocation-scoped LoggerAdapter
@@ -48,7 +49,8 @@ django-lambda-tasks/
 - `logging.py` — `task_logger` singleton; `message_id` set/cleared around each task execution
 - `settings.py` — constants (`MAX_DELAY`, `MAX_TIMEOUT`, `MAX_BATCH_TIMEOUT`); `_is_sqs_queue()` and `_is_batch_queue()` helpers; `LambdaTasksSettings` instantiated fresh per use (reads live Django settings); `queue_max_timeout()` method returns 900 or 3600 based on queue type
 - `admin.py` — Django admin registration for `TaskRecord`
-- `apps.py` — Django `AppConfig`; `ready()` installs the local-executor shutdown signal handlers when `LOCAL_WORKERS > 0`
+- `apps.py` — Django `AppConfig`; `ready()` imports `checks` to register deployment checks and installs the local-executor shutdown signal handlers when `LOCAL_WORKERS > 0`
+- `checks.py` — Django deployment checks; `check_noop_not_in_production` warns if `NOOP_EXECUTION`, `EAGER`, or `LOCAL_WORKERS > 0` are set (runs with `manage.py check --deploy`)
 - `tasks.py` — built-in tasks; `cleanup_task_records` deletes old `TaskRecord` rows; `submit_batch_job` receives a serialized task message and submits it to AWS Batch via `batch.submit_job()`
 
 ## Conventions

django_lambda_tasks-0.6.5/README.md → django_lambda_tasks-0.6.7/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: django-lambda-tasks
+Version: 0.6.7
+Summary: Run async tasks in a lambda function
+Requires-Python: >=3.10
+Requires-Dist: awslambdaric
+Requires-Dist: boto3
+Requires-Dist: django
+Requires-Dist: pydantic
+Requires-Dist: redis
+Description-Content-Type: text/markdown
+
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -181,9 +193,10 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 Async local mode bridges the gap between eager mode and full SQS/Lambda deployment. Tasks execute in background worker processes with true parallelism and full timeout enforcement via `SIGALRM`, without requiring AWS infrastructure.
 
 The execution mode hierarchy is:
-1. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS** (default) — async, Lambda workers, timeouts enforced
+1. **Noop** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS** (default) — async, Lambda workers, timeouts enforced
 
 Key characteristics:
 - `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`
@@ -196,6 +209,35 @@ Key characteristics:
 
 ---
 
+### Noop execution (testing)
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `bool` | `False` | When `True`, all tasks are silently dropped. A warning is logged with the task name, kwargs, and queue. |
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+Noop mode is useful for test suites where task execution is irrelevant and you want to avoid mocking SQS or running tasks at all. When a task is dispatched via `execute_on_commit()`, it logs a warning and returns immediately — no SQS message is sent, no task is executed, no `TaskRecord` is created.
+
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS` — setting it alongside either raises `ImproperlyConfigured`.
+
+### Deployment checks
+
+A Django deployment check (runs with `manage.py check --deploy`) warns if any non-production execution mode is enabled:
+
+| Check ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+Add `manage.py check --deploy` to your CI pipeline to catch these misconfigurations before they reach production.
+
+---
+
 ## Decorator options
 
 ```python

django_lambda_tasks-0.6.5/PKG-INFO → django_lambda_tasks-0.6.7/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: django-lambda-tasks
-Version: 0.6.5
-Summary: Run async tasks in a lambda function
-Requires-Python: >=3.10
-Requires-Dist: awslambdaric
-Requires-Dist: boto3
-Requires-Dist: django
-Requires-Dist: pydantic
-Requires-Dist: redis
-Description-Content-Type: text/markdown
-
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -193,9 +181,10 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 Async local mode bridges the gap between eager mode and full SQS/Lambda deployment. Tasks execute in background worker processes with true parallelism and full timeout enforcement via `SIGALRM`, without requiring AWS infrastructure.
 
 The execution mode hierarchy is:
-1. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS** (default) — async, Lambda workers, timeouts enforced
+1. **Noop** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS** (default) — async, Lambda workers, timeouts enforced
 
 Key characteristics:
 - `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`
@@ -208,6 +197,35 @@ Key characteristics:
 
 ---
 
+### Noop execution (testing)
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `bool` | `False` | When `True`, all tasks are silently dropped. A warning is logged with the task name, kwargs, and queue. |
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+Noop mode is useful for test suites where task execution is irrelevant and you want to avoid mocking SQS or running tasks at all. When a task is dispatched via `execute_on_commit()`, it logs a warning and returns immediately — no SQS message is sent, no task is executed, no `TaskRecord` is created.
+
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS` — setting it alongside either raises `ImproperlyConfigured`.
+
+### Deployment checks
+
+A Django deployment check (runs with `manage.py check --deploy`) warns if any non-production execution mode is enabled:
+
+| Check ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+Add `manage.py check --deploy` to your CI pipeline to catch these misconfigurations before they reach production.
+
+---
+
 ## Decorator options
 
 ```python

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/lambda_tasks/apps.py

@@ -15,6 +15,7 @@ class LambdaTasksConfig(AppConfig):
         on Ctrl+C, before Django's autoreloader parent SIGKILLs this child. See
         ``local_executor._install_shutdown_handlers`` for the full rationale.
         """
+        import lambda_tasks.checks  # noqa: F401 — register deployment checks
         from lambda_tasks.local_executor import _install_shutdown_handlers
         from lambda_tasks.settings import LambdaTasksSettings
 

django_lambda_tasks-0.6.7/lambda_tasks/checks.py

@@ -0,0 +1,45 @@
+"""Django deployment checks for lambda_tasks."""
+
+from django.conf import settings as django_settings
+from django.core.checks import Warning, register
+
+
+@register("lambda_tasks", deploy=True)
+def check_noop_not_in_production(
+    *, app_configs: object, **kwargs: object
+) -> list[Warning]:
+    """Warn if any non-production execution mode is enabled."""
+    warnings: list[Warning] = []
+
+    if bool(getattr(django_settings, "LAMBDA_TASKS_NOOP_EXECUTION", False)):
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_NOOP_EXECUTION is enabled. "
+                "Tasks will be silently dropped.",
+                hint="Set LAMBDA_TASKS_NOOP_EXECUTION = False for production.",
+                id="lambda_tasks.W001",
+            )
+        )
+
+    if bool(getattr(django_settings, "LAMBDA_TASKS_EAGER", False)):
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_EAGER is enabled. "
+                "Tasks will run synchronously in-process.",
+                hint="Set LAMBDA_TASKS_EAGER = False for production.",
+                id="lambda_tasks.W002",
+            )
+        )
+
+    local_workers = int(getattr(django_settings, "LAMBDA_TASKS_LOCAL_WORKERS", 0))
+    if local_workers > 0:
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_LOCAL_WORKERS is set to a positive value. "
+                "Tasks will run in a local process pool.",
+                hint="Set LAMBDA_TASKS_LOCAL_WORKERS = 0 for production.",
+                id="lambda_tasks.W003",
+            )
+        )
+
+    return warnings

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/lambda_tasks/handler.py

@@ -12,12 +12,13 @@ timeouts. The sequence is guarded by a module-level sentinel so subsequent
 warm invocations skip it.
 """
 
+import json
 import logging
 import os
 import resource
 import sys
+import urllib.request
 import uuid
-from pathlib import Path
 
 import django
 from django.apps import apps
@@ -32,37 +33,31 @@ _cold_start_done: bool = False
 
 _MEMORY_RESERVED_MB = 128
 _MEMORY_MINIMUM_LIMIT_MB = 64
-_CGROUP_V2_MEMORY_MAX_PATH = Path("/sys/fs/cgroup/memory.max")
-_CGROUP_V1_MEMORY_LIMIT_PATH = Path("/sys/fs/cgroup/memory/memory.limit_in_bytes")
 
 
 def _get_memory_mb() -> int | None:
-    """Get container memory limit from Lambda env var or cgroup."""
+    """Get container memory limit from Lambda env var or ECS metadata endpoint."""
     memory_mb_str = os.environ.get("AWS_LAMBDA_FUNCTION_MEMORY_SIZE")
     if memory_mb_str is not None:
         return int(memory_mb_str)
 
-    try:
-        value = _CGROUP_V2_MEMORY_MAX_PATH.read_text().strip()
-        if value == "max":
+    metadata_uri = os.environ.get("ECS_CONTAINER_METADATA_URI_V4")
+    if metadata_uri is not None:
+        try:
+            with urllib.request.urlopen(f"{metadata_uri}/task", timeout=2) as response:
+                data = json.loads(response.read())
+            return int(data["Limits"]["Memory"])
+        except Exception:
             return None
-        else:
-            return int(value) // (1024 * 1024)
-    except (FileNotFoundError, ValueError):
-        pass
 
-    try:
-        value = _CGROUP_V1_MEMORY_LIMIT_PATH.read_text().strip()
-        return int(value) // (1024 * 1024)
-    except (FileNotFoundError, ValueError):
-        return None
+    return None
 
 
 def _set_memory_limit() -> None:
     """Set RLIMIT_AS from the container memory limit.
 
     On Lambda, reads AWS_LAMBDA_FUNCTION_MEMORY_SIZE. On Fargate/Batch,
-    reads the cgroup v2 memory limit. This causes Python to raise
+    queries the ECS task metadata endpoint. This causes Python to raise
     MemoryError on excessive allocation instead of being killed by the
     OOM killer.
 

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/lambda_tasks/models.py

@@ -2,6 +2,7 @@
 
 import contextlib
 import datetime
+import logging
 import random
 import traceback
 import uuid
@@ -26,6 +27,8 @@ from lambda_tasks.settings import (
 )
 from lambda_tasks.timeouts import TimeoutContext
 
+logger = logging.getLogger("lambda_tasks")
+
 
 class MaxRetriesExceededError(Exception):
     def __init__(self, *, task_name: str, n_retries: int) -> None:
@@ -260,6 +263,13 @@ class SQSLambdaTask(BaseModel):
         """
         conf = LambdaTasksSettings()
 
+        if conf.NOOP_EXECUTION:
+            logger.warning(
+                f"Task {self.message.task_name} dropped (noop execution mode): "
+                f"kwargs={self.message.kwargs!r}, queue={self.queue!r}"
+            )
+            return
+
         if conf.EAGER:
             self.message.execute_immediately(message_id=str(uuid.uuid4()))
         elif conf.LOCAL_WORKERS > 0:

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/lambda_tasks/settings.py

@@ -108,3 +108,16 @@ class LambdaTasksSettings:
             )
         else:
             return value
+
+    @property
+    def NOOP_EXECUTION(self) -> bool:
+        value = bool(getattr(django_settings, "LAMBDA_TASKS_NOOP_EXECUTION", False))
+        if value and self.EAGER:
+            raise ImproperlyConfigured(
+                "LAMBDA_TASKS_NOOP_EXECUTION and LAMBDA_TASKS_EAGER are mutually exclusive."
+            )
+        if value and int(getattr(django_settings, "LAMBDA_TASKS_LOCAL_WORKERS", 0)) > 0:
+            raise ImproperlyConfigured(
+                "LAMBDA_TASKS_NOOP_EXECUTION and LAMBDA_TASKS_LOCAL_WORKERS are mutually exclusive."
+            )
+        return value

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["lambda_tasks"]
 
 [project]
 name = "django-lambda-tasks"
-version = "0.6.5"
+version = "0.6.7"
 description = "Run async tasks in a lambda function"
 readme = "README.md"
 requires-python = ">=3.10"

{django_lambda_tasks-0.6.5 → django_lambda_tasks-0.6.7}/tests/test_memory_limit.py

@@ -6,30 +6,18 @@ memory allocation raises MemoryError instead of triggering the Lambda OOM
 killer.
 """
 
+import json
 import resource
 
 import lambda_tasks.handler as handler_module
 
 
-class _FakePath:
-    def __init__(self, *, content: str | None) -> None:
-        self._content = content
-
-    def read_text(self) -> str:
-        if self._content is None:
-            raise FileNotFoundError
-        return self._content
-
-
-def fake_path(content: str | None) -> _FakePath:
-    return _FakePath(content=content)
-
-
 class TestMemoryLimitSetDuringColdStart:
     def test_rlimit_as_set_from_env_var(self, monkeypatch):
         """When AWS_LAMBDA_FUNCTION_MEMORY_SIZE is set, RLIMIT_AS is configured with 128 MB reserved."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "512")
+        monkeypatch.delenv("ECS_CONTAINER_METADATA_URI_V4", raising=False)
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
@@ -48,20 +36,15 @@ class TestMemoryLimitSetDuringColdStart:
         expected = (512 - 128) * 1024 * 1024
         assert calls == [(resource.RLIMIT_AS, (expected, expected))]
 
-    def test_rlimit_as_not_set_when_env_var_missing_and_no_cgroup(self, monkeypatch):
-        """When AWS_LAMBDA_FUNCTION_MEMORY_SIZE is not set and cgroup is unavailable, RLIMIT_AS is unchanged."""
+    def test_rlimit_as_not_set_when_no_memory_source(self, monkeypatch):
+        """When neither Lambda env var nor ECS metadata is available, RLIMIT_AS is unchanged."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.delenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", raising=False)
+        monkeypatch.delenv("ECS_CONTAINER_METADATA_URI_V4", raising=False)
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
         )
-        monkeypatch.setattr(
-            handler_module, "_CGROUP_V2_MEMORY_MAX_PATH", fake_path(None)
-        )
-        monkeypatch.setattr(
-            handler_module, "_CGROUP_V1_MEMORY_LIMIT_PATH", fake_path(None)
-        )
 
         calls: list[tuple] = []
 
@@ -75,25 +58,33 @@ class TestMemoryLimitSetDuringColdStart:
 
         assert calls == []
 
-    def test_rlimit_as_set_from_cgroup_v2(self, monkeypatch):
-        """When AWS_LAMBDA_FUNCTION_MEMORY_SIZE is not set, falls back to cgroup v2."""
+    def test_rlimit_as_set_from_ecs_metadata(self, monkeypatch):
+        """When ECS_CONTAINER_METADATA_URI_V4 is set, queries the task endpoint for memory."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.delenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", raising=False)
+        monkeypatch.setenv("ECS_CONTAINER_METADATA_URI_V4", "http://169.254.170.2/v4")
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
         )
-        # 2 GB in bytes
-        monkeypatch.setattr(
-            handler_module,
-            "_CGROUP_V2_MEMORY_MAX_PATH",
-            fake_path(str(2048 * 1024 * 1024)),
-        )
-        monkeypatch.setattr(
-            handler_module,
-            "_CGROUP_V1_MEMORY_LIMIT_PATH",
-            fake_path(None),
-        )
+
+        task_metadata = json.dumps({"Limits": {"CPU": 2, "Memory": 8192}}).encode()
+
+        class FakeResponse:
+            def read(self):
+                return task_metadata
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *args):
+                pass
+
+        def fake_urlopen(url, *, timeout=None):
+            assert url == "http://169.254.170.2/v4/task"
+            return FakeResponse()
+
+        monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
 
         calls: list[tuple] = []
 
@@ -105,23 +96,23 @@ class TestMemoryLimitSetDuringColdStart:
         handler_module._cold_start_done = False
         handler_module.handler(event={"Records": []}, context=None)
 
-        expected = (2048 - 128) * 1024 * 1024
+        expected = (8192 - 128) * 1024 * 1024
         assert calls == [(resource.RLIMIT_AS, (expected, expected))]
 
-    def test_rlimit_as_not_set_when_cgroup_is_max(self, monkeypatch):
-        """When cgroup memory.max is 'max' (unlimited), RLIMIT_AS is unchanged."""
+    def test_rlimit_as_not_set_when_ecs_metadata_fails(self, monkeypatch):
+        """When ECS metadata endpoint fails, RLIMIT_AS is unchanged."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.delenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", raising=False)
+        monkeypatch.setenv("ECS_CONTAINER_METADATA_URI_V4", "http://169.254.170.2/v4")
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
         )
-        monkeypatch.setattr(
-            handler_module, "_CGROUP_V2_MEMORY_MAX_PATH", fake_path("max")
-        )
-        monkeypatch.setattr(
-            handler_module, "_CGROUP_V1_MEMORY_LIMIT_PATH", fake_path(None)
-        )
+
+        def fake_urlopen(url, *, timeout=None):
+            raise OSError("connection refused")
+
+        monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
 
         calls: list[tuple] = []
 
@@ -135,25 +126,15 @@ class TestMemoryLimitSetDuringColdStart:
 
         assert calls == []
 
-    def test_rlimit_as_set_from_cgroup_v1(self, monkeypatch):
-        """When cgroup v2 is unavailable, falls back to cgroup v1 (Fargate)."""
+    def test_lambda_env_var_takes_precedence_over_ecs_metadata(self, monkeypatch):
+        """AWS_LAMBDA_FUNCTION_MEMORY_SIZE is preferred over ECS metadata."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
-        monkeypatch.delenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", raising=False)
+        monkeypatch.setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "512")
+        monkeypatch.setenv("ECS_CONTAINER_METADATA_URI_V4", "http://169.254.170.2/v4")
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
         )
-        monkeypatch.setattr(
-            handler_module,
-            "_CGROUP_V2_MEMORY_MAX_PATH",
-            fake_path(None),
-        )
-        # 4 GB in bytes
-        monkeypatch.setattr(
-            handler_module,
-            "_CGROUP_V1_MEMORY_LIMIT_PATH",
-            fake_path(str(4096 * 1024 * 1024)),
-        )
 
         calls: list[tuple] = []
 
@@ -165,13 +146,14 @@ class TestMemoryLimitSetDuringColdStart:
         handler_module._cold_start_done = False
         handler_module.handler(event={"Records": []}, context=None)
 
-        expected = (4096 - 128) * 1024 * 1024
+        expected = (512 - 128) * 1024 * 1024
         assert calls == [(resource.RLIMIT_AS, (expected, expected))]
 
     def test_memory_limit_set_before_loaders(self, monkeypatch):
         """The memory limit is set before resolve_environment runs."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "256")
+        monkeypatch.delenv("ECS_CONTAINER_METADATA_URI_V4", raising=False)
 
         call_order: list[str] = []
 
@@ -207,6 +189,7 @@ class TestMemoryLimitSetDuringColdStart:
 
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "1024")
+        monkeypatch.delenv("ECS_CONTAINER_METADATA_URI_V4", raising=False)
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None
@@ -224,6 +207,7 @@ class TestMemoryLimitSetDuringColdStart:
         """When AWS_LAMBDA_FUNCTION_MEMORY_SIZE <= reserved, RLIMIT_AS is set to the 64 MB minimum."""
         monkeypatch.delenv("DJANGO_SETTINGS_MODULE", raising=False)
         monkeypatch.setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "128")
+        monkeypatch.delenv("ECS_CONTAINER_METADATA_URI_V4", raising=False)
         monkeypatch.setattr("lambda_tasks.handler.resolve_environment", lambda: None)
         monkeypatch.setattr(
             "lambda_tasks.handler.resolve_secrets_into_env", lambda: None

django_lambda_tasks-0.6.7/tests/test_noop_execution.py

@@ -0,0 +1,165 @@
+"""Tests for LAMBDA_TASKS_NOOP_EXECUTION setting and deployment check."""
+
+import logging
+from unittest.mock import patch
+
+import pytest
+from django.core.exceptions import ImproperlyConfigured
+
+DEFAULT_QUEUE = {
+    "queue_url": "https://sqs.us-east-1.amazonaws.com/000000000000/default"
+}
+QUEUES = {"default": DEFAULT_QUEUE}
+
+
+# ---------------------------------------------------------------------------
+# NOOP_EXECUTION setting property
+# ---------------------------------------------------------------------------
+
+
+def test_noop_execution_defaults_to_false():
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    conf = LambdaTasksSettings()
+    assert conf.NOOP_EXECUTION is False
+
+
+def test_noop_execution_true(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    conf = LambdaTasksSettings()
+    assert conf.NOOP_EXECUTION is True
+
+
+def test_noop_execution_with_eager_raises(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    conf = LambdaTasksSettings()
+    with pytest.raises(ImproperlyConfigured):
+        _ = conf.NOOP_EXECUTION
+
+
+def test_noop_execution_with_local_workers_raises(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    conf = LambdaTasksSettings()
+    with pytest.raises(ImproperlyConfigured):
+        _ = conf.NOOP_EXECUTION
+
+
+# ---------------------------------------------------------------------------
+# _execute() noop behaviour
+# ---------------------------------------------------------------------------
+
+
+def test_execute_noop_does_not_call_sqs(settings):
+    from lambda_tasks.models import SQSLambdaTask, SQSLambdaTaskMessage
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    settings.LAMBDA_TASKS_QUEUES = QUEUES
+
+    message = SQSLambdaTaskMessage(
+        task_name="myapp.tasks.my_task",
+        kwargs={"user_id": 1},
+        n_retries=0,
+    )
+    task = SQSLambdaTask(message=message, delay=0, queue="default")
+
+    with patch("lambda_tasks.models.boto3") as mock_boto3:
+        task._execute()
+        mock_boto3.client.assert_not_called()
+
+
+def test_execute_noop_logs_warning(settings, caplog):
+    from lambda_tasks.models import SQSLambdaTask, SQSLambdaTaskMessage
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    settings.LAMBDA_TASKS_QUEUES = QUEUES
+
+    message = SQSLambdaTaskMessage(
+        task_name="myapp.tasks.my_task",
+        kwargs={"user_id": 42},
+        n_retries=0,
+    )
+    task = SQSLambdaTask(message=message, delay=0, queue="default")
+
+    with caplog.at_level(logging.WARNING, logger="lambda_tasks"):
+        task._execute()
+
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "WARNING"
+    assert "myapp.tasks.my_task" in record.message
+    assert "noop" in record.message.lower()
+    assert "{'user_id': 42}" in record.message
+
+
+# ---------------------------------------------------------------------------
+# Django deployment check
+# ---------------------------------------------------------------------------
+
+
+def test_deployment_check_passes_when_all_false(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert errors == []
+
+
+def test_deployment_check_warns_noop(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W001"
+
+
+def test_deployment_check_warns_eager(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W002"
+
+
+def test_deployment_check_warns_local_workers(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W003"
+
+
+def test_deployment_check_warns_multiple(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 3