chore: ai auto update debounce (baserow#4378)

* run ai model values in paralllel baserow#4227

* review fixes

* reworked ai threaded execution

* review fixes

* lint fix after rebase/conflict, removed unused serializer fields

* Debounce ai field value generation from auto-update. baserow#4317

* failing test sanity check

* review fixes

* review fixes

* review fix

* review fixes

* Ensure tasks are re-scheduled on changes during generation

* Debug: Add container logs on E2E service startup failure

* Move serializer to the correct file

* lint fixes

* Fix filter empty values

* address feedback

* Fix flaky test

* Fix tests

* Add comment for sync=True, as suggested

---------

Co-authored-by: Davide Silvestri <silvestri.eng@gmail.com>

Author: cezary-baserow

.github/workflows/ci.yml

@@ -733,6 +733,21 @@ jobs:
           cd e2e-tests
           ./wait-for-services.sh
 
+      - name: Show container logs on failure
+        if: failure()
+        run: |
+          echo "=== Backend container logs ==="
+          docker logs backend 2>&1 | tail -500 || true
+          echo ""
+          echo "=== Celery container logs ==="
+          docker logs celery 2>&1 | tail -200 || true
+          echo ""
+          echo "=== Web-frontend container logs ==="
+          docker logs web-frontend 2>&1 | tail -200 || true
+          echo ""
+          echo "=== Container status ==="
+          docker ps -a
+
       - name: Run E2E tests (shard ${{ matrix.shard }})
         env:
           PUBLIC_BACKEND_URL: http://localhost:8000

backend/src/baserow/celery_singleton_backend.py

@@ -1,3 +1,6 @@
+from django.conf import settings
+from django.core.cache import cache
+
 from celery_singleton.backends import RedisBackend
 from django_redis import get_redis_connection
 
@@ -9,3 +12,45 @@ def __init__(self, *args, **kwargs):
         """
 
         self.redis = get_redis_connection("default")
+
+
+class SingletonAutoRescheduleFlag:
+    """
+    Flag is used to indicate that a task of this type is pending reschedule.
+
+    When the task ends, if this flag is set, it will re-schedule itself to
+    ensure that task is eventually run.
+    """
+
+    def __init__(self, key: str):
+        self.key = key
+
+    def is_set(self) -> bool:
+        """
+        Checks if the flag is set.
+
+        :return: True if the lock is set, False otherwise.
+        """
+
+        return cache.get(key=self.key) or False
+
+    def set(self) -> bool:
+        """
+        Sets the flag for the task, indicating it needs to be rescheduled.
+
+        :return: True if the flag was set, False if it was already set.
+        """
+
+        return cache.set(
+            key=self.key,
+            value=True,
+            timeout=settings.AUTO_INDEX_LOCK_EXPIRY * 2,
+        )
+
+    def clear(self) -> bool:
+        """
+        Clears the flag for the task.
+        :return: True if the flag was cleared, False otherwise.
+        """
+
+        return cache.delete(key=self.key)

backend/src/baserow/contrib/database/search/tasks.py

@@ -2,13 +2,13 @@
 from typing import List, Optional
 
 from django.conf import settings
-from django.core.cache import cache
 from django.db.models import Q
 
 from celery_singleton import DuplicateTaskError, Singleton
 from django_cte import With
 from loguru import logger
 
+from baserow.celery_singleton_backend import SingletonAutoRescheduleFlag
 from baserow.config.celery import app
 from baserow.contrib.database.search.models import PendingSearchValueUpdate
 from baserow.contrib.database.table.exceptions import TableDoesNotExist
@@ -17,53 +17,8 @@
 PERIODIC_CHECK_TIME_LIMIT = 60 * PERIODIC_CHECK_MINUTES  # 15 minutes.
 
 
-class PendingSearchUpdateFlag:
-    """
-    Flag is used to indicate that a search data update task is pending for a
-    specific table and it has not been possible to schedule it yet due to a concurrent
-    task already running for the same table.
-
-    When the task ends, if this flag is set, it will re-schedule itself to ensure that
-    the search data is eventually updated.
-    """
-
-    def __init__(self, table_id: int):
-        self.table_id = table_id
-
-    @property
-    def key(self):
-        """
-        Returns the cache key to use for the table lock.
-        """
-
-        return f"database_search_data_lock_{self.table_id}"
-
-    def get(self):
-        """
-        Gets the lock for the search data update task.
-
-        :return: True if the lock is set, False otherwise.
-        """
-
-        return cache.get(key=self.key)
-
-    def set(self):
-        """
-        Sets the lock for the search data update task.
-        """
-
-        return cache.set(
-            key=self.key,
-            value=True,
-            timeout=settings.AUTO_INDEX_LOCK_EXPIRY * 2,
-        )
-
-    def clear(self):
-        """
-        Clears the lock for the search data update task.
-        """
-
-        return cache.delete(key=self.key)
+def _get_singleton_autoreschedule_flag(table_id: int) -> SingletonAutoRescheduleFlag:
+    return SingletonAutoRescheduleFlag(f"database_search_data_lock_{table_id}")
 
 
 @app.task(queue="export")
@@ -114,7 +69,8 @@ def schedule_update_search_data(
         # There are new updates pending to be processed, make sure the flag is set
         # so the task will be re-scheduled at the end of the current run.
         if new_pending_updates:
-            PendingSearchUpdateFlag(table_id).set()
+            flag = _get_singleton_autoreschedule_flag(table_id)
+            flag.set()
 
 
 @app.task(
@@ -162,13 +118,13 @@ def update_search_data(table_id: int):
     SearchHandler.initialize_missing_search_data(table)
 
     # Make sure newer updates will re-schedule this task at the end if needed.
-    flag = PendingSearchUpdateFlag(table_id)
+    flag = _get_singleton_autoreschedule_flag(table_id)
     flag.clear()
 
     SearchHandler.process_search_data_updates(table)
 
     # If new updates were queued during processing, schedule another update
-    if flag.get():
+    if flag.is_set():
         logger.debug(
             f"New updates detected, rescheduling the task for table {table_id}."
         )

backend/src/baserow/core/jobs/tasks.py

@@ -46,7 +46,7 @@ def run_async_job(self, job_id: int):
             job.set_state_cancelled()
             job.save()
         except BaseException as e:
-            # We also want to catch SystemExit exception here and all other possible
+            # BaseException allows catching SystemExit exceptions and all other possible
             # exceptions to set the job state in a failed state.
             error = f"Something went wrong during the {job_type.type} job execution."
 

backend/tests/baserow/core/test_basic_permissions.py

@@ -243,7 +243,7 @@ def test_workspace_member_permission_manager(data_fixture, django_assert_num_que
         perm_manager.check_permissions(
             user, ListApplicationsWorkspaceOperationType.type, workspace_2, workspace_2
         )
-    except Exception:  # noqa:W0718
+    except Exception:  # noqa
         ...
 
     with django_assert_num_queries(0):

changelog/entries/unreleased/refactor/4317_debounce_ai_field_value_from_auto_update.json

@@ -0,0 +1,9 @@
+{
+    "type": "refactor",
+    "message": "Debounce AI field value generation, that has been triggered from auto update.",
+    "issue_origin": "github",
+    "issue_number": 4317,
+    "domain": "database",
+    "bullet_points": [],
+    "created_at": "2025-12-03"
+}

docs/installation/configuration.md

@@ -150,6 +150,7 @@ The installation methods referred to in the variable descriptions are:
 | BASEROW\_OLLAMA\_HOST             | Provide an OLLAMA host to allow using OLLAMA for generative AI features like the AI field.                                                                                                                                                                                                                                                                  |          |
 | BASEROW\_OLLAMA\_MODELS           | Provide a comma separated list of Ollama models (https://ollama.com/library) that you would like to enable in the instance (e.g. `llama2`). Note that this only works if an Ollama host is set. If this variable is not provided, the user won't be able to choose a model.                                                                                 |          |
 | BASEROW\_AI\_FIELD\_MAX\_CONCURRENT\_GENERATIONS | If AI field values are recalculated in a large number (i.e. recalculating whole table, empty rows, or a selection of rows), this controls the number of concurrent requests issued to AI model to generate values.                                                                                                                                          | 5       |
+| BASEROW\_AI\_FIELD\_AUTO\_UPDATE\_DEBOUNCE\_TIME | Debounce time in seconds for AI field updates scheduled from auto-update feature. If AI field has auto-update feature enabled, and many changes occur on fields that are referenced by that AI field, this will delay AI field generation by a number of seconds to accumulate many short updates into one bigger.                                           | 3       |
 
 ### Backend Misc Configuration
 | Name                                                                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Defaults               |

premium/backend/src/baserow_premium/api/fields/serializers.py

@@ -37,3 +37,15 @@ class GenerateFormulaWithAIRequestSerializer(serializers.Serializer):
 
 class GenerateFormulaWithAIResponseSerializer(serializers.Serializer):
     formula = serializers.CharField(help_text="The formula generated by the AI.")
+
+
+class GenerateAIValuesJobFiltersSerializer(serializers.Serializer):
+    """
+    Adds the ability to filter GenerateAIValuesJob by AI field ID.
+    """
+
+    generate_ai_values_field_id = serializers.IntegerField(
+        min_value=1,
+        required=False,
+        help_text="Filter by the AI field ID.",
+    )

premium/backend/src/baserow_premium/apps.py

@@ -263,3 +263,5 @@ def ready(self):
         )
         widget_type_registry.register(ChartWidgetType())
         widget_type_registry.register(PieChartWidgetType())
+
+        from baserow_premium.fields import tasks  # noqa: F401

premium/backend/src/baserow_premium/config/settings/settings.py

@@ -40,3 +40,9 @@ def setup(settings):
     settings.BASEROW_AI_FIELD_MAX_CONCURRENT_GENERATIONS = try_int(
         os.getenv("BASEROW_AI_FIELD_MAX_CONCURRENT_GENERATIONS"), 5
     )
+
+    # Debounce time for AI field generation, if changes are triggered from
+    # auto-update feature. In seconds.
+    settings.BASEROW_AI_FIELD_AUTO_UPDATE_DEBOUNCE_TIME = try_int(
+        os.getenv("BASEROW_AI_FIELD_AUTO_UPDATE_DEBOUNCE_TIME"), 3
+    )