arangodb
diff --git a/‎arangod/Agency/Agent.cpp
Lines changed: 2 additions & 9 deletions b/‎arangod/Agency/Agent.cpp
Lines changed: 2 additions & 9 deletions
diff --git a/‎arangod/Aql/ExecutionBlockImpl.cpp
Lines changed: 14 additions & 15 deletions b/‎arangod/Aql/ExecutionBlockImpl.cpp
Lines changed: 14 additions & 15 deletions
diff --git a/‎arangod/Aql/SharedQueryState.cpp
Lines changed: 2 additions & 2 deletions b/‎arangod/Aql/SharedQueryState.cpp
Lines changed: 2 additions & 2 deletions
diff --git a/‎arangod/Cache/CacheManagerFeature.cpp
Lines changed: 2 additions & 1 deletion b/‎arangod/Cache/CacheManagerFeature.cpp
Lines changed: 2 additions & 1 deletion
diff --git a/‎arangod/Cluster/AgencyCache.cpp
Lines changed: 1 addition & 7 deletions b/‎arangod/Cluster/AgencyCache.cpp
Lines changed: 1 addition & 7 deletions
diff --git a/‎arangod/Cluster/ClusterInfo.cpp
Lines changed: 1 addition & 7 deletions b/‎arangod/Cluster/ClusterInfo.cpp
Lines changed: 1 addition & 7 deletions
diff --git a/‎arangod/Cluster/HeartbeatThread.cpp
Lines changed: 5 additions & 20 deletions b/‎arangod/Cluster/HeartbeatThread.cpp
Lines changed: 5 additions & 20 deletions
diff --git a/‎arangod/Cluster/RebootTracker.cpp
Lines changed: 1 addition & 7 deletions b/‎arangod/Cluster/RebootTracker.cpp
Lines changed: 1 addition & 7 deletions
diff --git a/‎arangod/GeneralServer/CommTask.cpp
Lines changed: 3 additions & 3 deletions b/‎arangod/GeneralServer/CommTask.cpp
Lines changed: 3 additions & 3 deletions
diff --git a/‎arangod/IResearch/IResearchAnalyzerFeature.cpp
Lines changed: 3 additions & 19 deletions b/‎arangod/IResearch/IResearchAnalyzerFeature.cpp
Lines changed: 3 additions & 19 deletions
@@ -1517,13 +1517,7 @@ void Agent::triggerPollsNoLock(query_t qu, SteadyTimePoint const& tp) {
   while (pit != _promises.end()) {
     if (pit->first < tp) {
       auto pp = std::make_shared<futures::Promise<query_t>>(std::move(pit->second));
-      bool queued = scheduler->queue(
-        RequestLane::CLUSTER_INTERNAL, [pp, qu] { pp->setValue(qu); });
-      if (!queued) {
-        LOG_TOPIC("3647c", WARN, Logger::AGENCY) <<
-          "Failed to schedule logsForTrigger running in main thread";
-        pp->setValue(qu);
-      }
+      scheduler->queue(RequestLane::CLUSTER_INTERNAL, [pp, qu] { pp->setValue(qu); });
       pit = _promises.erase(pit);
     } else {
       ++pit;
@@ -2314,13 +2308,12 @@ void Agent::emptyCbTrashBin() {
   // queue + write.
   auto* scheduler = SchedulerFeature::SCHEDULER;
   if (scheduler != nullptr) {
-    bool ok = scheduler->queue(RequestLane::INTERNAL_LOW, [&server = server(), envelope = std::move(envelope)] {
+    scheduler->queue(RequestLane::INTERNAL_LOW, [&server = server(), envelope = std::move(envelope)] {
         auto* agent = server.getFeature<AgencyFeature>().agent();
         if (!server.isStopping() && agent) {
           agent->write(envelope);
         }
       });
-    LOG_TOPIC_IF("52461", DEBUG, Logger::AGENCY, !ok) << "Could not schedule callback cleanup job.";
   }
 
 }
 
@@ -781,21 +781,20 @@ auto ExecutionBlockImpl<Executor>::executeFetcher(ExecutionContext& ctx,
 
       // we can safely ignore the result here, because we will try to
       // claim the task ourselves anyway.
-      std::ignore =
-          SchedulerFeature::SCHEDULER->queue(RequestLane::INTERNAL_LOW,
-                                             [block = this, task = _prefetchTask,
-                                              stack = ctx.stack]() mutable {
-                                               if (!task->tryClaim()) {
-                                                 return;
-                                               }
-                                               // task is a copy of the PrefetchTask shared_ptr, and we will only
-                                               // attempt to execute the task if we successfully claimed the task.
-                                               // i.e., it does not matter if this task lingers around in the
-                                               // scheduler queue even after the execution block has been destroyed,
-                                               // because in this case we will not be able to claim the task and
-                                               // simply return early without accessing the block.
-                                               task->execute(*block, stack);
-                                             });
+      SchedulerFeature::SCHEDULER->queue(RequestLane::INTERNAL_LOW,
+                                          [block = this, task = _prefetchTask,
+                                          stack = ctx.stack]() mutable {
+                                            if (!task->tryClaim()) {
+                                              return;
+                                            }
+                                            // task is a copy of the PrefetchTask shared_ptr, and we will only
+                                            // attempt to execute the task if we successfully claimed the task.
+                                            // i.e., it does not matter if this task lingers around in the
+                                            // scheduler queue even after the execution block has been destroyed,
+                                            // because in this case we will not be able to claim the task and
+                                            // simply return early without accessing the block.
+                                            task->execute(*block, stack);
+                                          });
     }
 
     if constexpr (!std::is_same_v<Executor, SubqueryStartExecutor>) {
 
@@ -134,7 +134,7 @@ void SharedQueryState::queueHandler() {
                         : RequestLane::CLUSTER_AQL;
 
-  bool queued = scheduler->queue(lane, [self = shared_from_this(),
+  bool queued = scheduler->tryBoundedQueue(lane, [self = shared_from_this(),
                                         cb = _wakeupCb, v = _cbVersion]() {
     std::unique_lock<std::mutex> lck(self->_mutex, std::defer_lock);
 
@@ -172,7 +172,7 @@ void SharedQueryState::queueHandler() {
 bool SharedQueryState::queueAsyncTask(fu2::unique_function<void()> cb) {
   Scheduler* scheduler = SchedulerFeature::SCHEDULER;
   if (scheduler) {
-    return scheduler->queue(RequestLane::CLUSTER_AQL, std::move(cb));
+    return scheduler->tryBoundedQueue(RequestLane::CLUSTER_AQL, std::move(cb));
   }
   return false;
 }
@@ -102,7 +102,8 @@ void CacheManagerFeature::start() {
   auto scheduler = SchedulerFeature::SCHEDULER;
   auto postFn = [scheduler](std::function<void()> fn) -> bool {
     try {
-      return scheduler->queue(RequestLane::INTERNAL_LOW, std::move(fn));
+      scheduler->queue(RequestLane::INTERNAL_LOW, std::move(fn));
+      return true;
     } catch (...) {
       return false;
     }
 
@@ -490,13 +490,7 @@ void AgencyCache::triggerWaiting(index_t commitIndex) {
     }
     auto pp = std::make_shared<futures::Promise<Result>>(std::move(pit->second));
     if (scheduler && !this->isStopping()) {
-      bool queued = scheduler->queue(
-        RequestLane::CLUSTER_INTERNAL, [pp] { pp->setValue(Result()); });
-      if (!queued) {
-        LOG_TOPIC("c6473", WARN, Logger::AGENCY) <<
-          "Failed to schedule logsForTrigger running in main thread";
-        pp->setValue(Result());
-      }
+      scheduler->queue(RequestLane::CLUSTER_INTERNAL, [pp] { pp->setValue(Result()); });
     } else {
       pp->setValue(Result(_shutdownCode));
     }
 
@@ -6511,13 +6511,7 @@ void ClusterInfo::triggerWaiting(
     }
     auto pp = std::make_shared<futures::Promise<Result>>(std::move(pit->second));
     if (scheduler && !_server.isStopping()) {
-      bool queued = scheduler->queue(
-        RequestLane::CLUSTER_INTERNAL, [pp] { pp->setValue(Result()); });
-      if (!queued) {
-        LOG_TOPIC("4637c", WARN, Logger::AGENCY) <<
-          "Failed to schedule logsForTrigger running in main thread";
-        pp->setValue(Result());
-      }
+      scheduler->queue(RequestLane::CLUSTER_INTERNAL, [pp] { pp->setValue(Result()); });
     } else {
       pp->setValue(Result(_syncerShutdownCode));
     }
 
@@ -495,19 +495,12 @@ void HeartbeatThread::runDBServer() {
         auto self = shared_from_this();
         Scheduler* scheduler = SchedulerFeature::SCHEDULER;
         *getNewsRunning = 1;
-        bool queued = scheduler->queue(RequestLane::CLUSTER_INTERNAL, [self, getNewsRunning] {
+        scheduler->queue(RequestLane::CLUSTER_INTERNAL, [self, getNewsRunning] {
           self->getNewsFromAgencyForDBServer();
           *getNewsRunning = 0;  // indicate completion to trigger a new schedule
         });
-        if (!queued && !isStopping()) {
-          LOG_TOPIC("aacce", WARN, Logger::HEARTBEAT)
-              << "Could not schedule getNewsFromAgency job in scheduler. Don't "
-                 "worry, this will be tried again later.";
-          *getNewsRunning = 0;
-        } else {
-          LOG_TOPIC("aaccf", DEBUG, Logger::HEARTBEAT)
-              << "Have scheduled getNewsFromAgency job.";
-        }
+        LOG_TOPIC("aaccf", DEBUG, Logger::HEARTBEAT)
+            << "Have scheduled getNewsFromAgency job.";
       }
 
       if (isStopping()) {
@@ -1088,19 +1081,11 @@ void HeartbeatThread::runCoordinator() {
         auto self = shared_from_this();
         Scheduler* scheduler = SchedulerFeature::SCHEDULER;
         *getNewsRunning = 1;
-        bool queued = scheduler->queue(RequestLane::CLUSTER_INTERNAL, [self, getNewsRunning] {
+        scheduler->queue(RequestLane::CLUSTER_INTERNAL, [self, getNewsRunning] {
           self->getNewsFromAgencyForCoordinator();
           *getNewsRunning = 0;  // indicate completion to trigger a new schedule
         });
-        if (!queued) {
-          LOG_TOPIC("aacc2", WARN, Logger::HEARTBEAT)
-              << "Could not schedule getNewsFromAgency job in scheduler. Don't "
-                 "worry, this will be tried again later.";
-          *getNewsRunning = 0;
-        } else {
-          LOG_TOPIC("aacc3", DEBUG, Logger::HEARTBEAT)
-              << "Have scheduled getNewsFromAgency job.";
-        }
+        LOG_TOPIC("aacc3", DEBUG, Logger::HEARTBEAT) << "Have scheduled getNewsFromAgency job.";
       }
 
       CONDITION_LOCKER(locker, _condition);
 
@@ -285,13 +285,7 @@ void RebootTracker::queueCallbacks(
                           [](auto it) { return it->empty(); }));
 
   auto cb = createSchedulerCallback(std::move(callbacks));
-
-  if (!_scheduler->queue(RequestLane::CLUSTER_INTERNAL, std::move(cb))) {
-    THROW_ARANGO_EXCEPTION_MESSAGE(
-        TRI_ERROR_QUEUE_FULL,
-        "No available threads when trying to queue cleanup "
-        "callbacks due to a server reboot");
-  }
+  _scheduler->queue(RequestLane::CLUSTER_INTERNAL, std::move(cb));
 }
 
 void RebootTracker::unregisterCallback(PeerState const& peerState,
 
@@ -507,7 +507,7 @@ bool CommTask::handleRequestSync(std::shared_ptr<RestHandler> handler) {
       }
     });
   };
-  bool ok = SchedulerFeature::SCHEDULER->queue(lane, std::move(cb));
+  bool ok = SchedulerFeature::SCHEDULER->tryBoundedQueue(lane, std::move(cb));
 
   if (!ok) {
     sendErrorResponse(rest::ResponseCode::SERVICE_UNAVAILABLE,
@@ -542,7 +542,7 @@ bool CommTask::handleRequestAsync(std::shared_ptr<RestHandler> handler,
     *jobId = handler->handlerId();
 
     // callback will persist the response with the AsyncJobManager
-    return SchedulerFeature::SCHEDULER->queue(lane, [handler = std::move(handler), manager(&jobManager)] {
+    return SchedulerFeature::SCHEDULER->tryBoundedQueue(lane, [handler = std::move(handler), manager(&jobManager)] {
       handler->trackQueueEnd();
       handler->trackTaskStart();
 
@@ -553,7 +553,7 @@ bool CommTask::handleRequestAsync(std::shared_ptr<RestHandler> handler,
     });
   } else {
     // here the response will just be ignored
-    return SchedulerFeature::SCHEDULER->queue(lane, [handler = std::move(handler)] {
+    return SchedulerFeature::SCHEDULER->tryBoundedQueue(lane, [handler = std::move(handler)] {
       handler->trackQueueEnd();
       handler->trackTaskStart();
 
 
@@ -775,25 +775,9 @@ AnalyzerModificationTransaction::Ptr createAnalyzerModificationTransaction(
 // Auto-repair of dangling AnalyzersRevisions
 void queueGarbageCollection(std::mutex& mutex, Scheduler::WorkHandle& workItem,
                             std::function<void(bool)>& gcfunc) {
-  bool queued = false;
-  {
-    std::lock_guard<std::mutex> guard(mutex);
-    std::tie(queued, workItem) =
-        basics::function_utils::retryUntilTimeout<Scheduler::WorkHandle>(
-            [&gcfunc]() -> std::pair<bool, Scheduler::WorkHandle> {
-              auto off = std::chrono::seconds(5);
-              return SchedulerFeature::SCHEDULER->queueDelay(RequestLane::INTERNAL_LOW,
-                                                             off, gcfunc);
-            },
-            arangodb::iresearch::TOPIC,
-            "queue analyzers garbage collection");
-  }
-  if (!queued) {
-    LOG_TOPIC("f25ad", FATAL, arangodb::iresearch::TOPIC)
-        << "Failed to queue analyzers garbage collection, for 5 minutes, "
-           "exiting.";
-    FATAL_ERROR_EXIT();
-  }
+  std::lock_guard<std::mutex> guard(mutex);
+  workItem = SchedulerFeature::SCHEDULER->queueDelayed(
+    RequestLane::INTERNAL_LOW, std::chrono::seconds(5), gcfunc);
 }
 
 // first - input type,