@fleetbase/fleetops-engine 0.6.65 → 0.6.67

package/docs/TELEMATICS_QUEUES.md

@@ -0,0 +1,179 @@
+# Dedicated telematics queue workers
+
+By default, all telematics work runs on the `default` queue alongside every other
+background job. On an instance with a large fleet, that work can crowd out
+notifications, order events, and other jobs. This guide moves telematics work to
+its own queues so dedicated worker containers process it while the existing
+worker keeps serving `default`.
+
+This is an **opt-in, per-instance** setup. With no environment variables set,
+nothing changes: every job and broadcast stays on the same queue as before.
+
+## What each setting routes
+
+| Setting | Default | Work routed |
+| --- | --- | --- |
+| `TELEMATICS_POLL_QUEUE` | `default` | Scheduled and manual polls (`PollTelematicTelemetry`), legacy device discovery (`SyncTelematicDevicesJob`), and queued connection tests (`TestTelematicConnectionJob`). |
+| `TELEMATICS_INGESTION_QUEUE` | `default` | Applying polled or pushed positions (`ProcessTelematicDelivery`), including jobs re-queued by `fleetops:drain-telematic-inbox` and manual replays. |
+| `TELEMATICS_BROADCAST_QUEUE` | unset | Live-map broadcasts created by telematics ingestion: `DeviceTelemetryUpdated`, and `VehicleLocationChanged` / `TrailerLocationChanged` when a device is attached. When unset, broadcasts use the queue connection's default queue. |
+
+`TELEMATICS_BROADCAST_QUEUE` affects only broadcasts that telematics ingestion
+creates. Vehicle and trailer location broadcasts from the driver app and public API
+remain on the default queue.
+
+Broadcasts can outnumber sync jobs. Each ingested unit with a newer position or
+contact time queues one device broadcast, plus one vehicle or trailer broadcast
+when attached. A fleet that reports every minute can queue hundreds of broadcast
+jobs per minute, so route broadcasts as well as polling and ingestion.
+
+## Before you start: check which sync path the provider uses
+
+Separate workers keep telematics from blocking other jobs. They do not make a slow
+sync faster, and they do not fix an unsafe job.
+
+- **Bounded polling path** (Safee scheduled and manual syncs; AFAQY scheduled polls
+  with `AFAQY_POLLING_ENABLED=true`): poll attempts are limited to an 80-second
+  hard timeout and a 60-second sweep budget, and ingestion yields every 40 seconds. These jobs are safe for the stock Redis
+  `retry_after` of 90 seconds and for multiple concurrent workers.
+- **Legacy discovery path** (other providers, AFAQY manual syncs, and AFAQY scheduled
+  syncs while polling is disabled):
+  `SyncTelematicDevicesJob` allows a 3,600-second run while Redis `retry_after`
+  is 90 seconds. A run lasting over 90 seconds can be handed to another worker and
+  end with `SyncTelematicDevicesJob has been attempted too many times`. Adding
+  workers increases the likelihood that another worker picks it up. Where possible,
+  move the provider to the bounded polling path, for example by setting
+  `AFAQY_POLLING_ENABLED=true` for AFAQY connections.
+
+## Setup
+
+Start the workers **before** setting the queue variables. Jobs sent to a queue with
+no worker wait indefinitely.
+
+### 1. Add telematics workers
+
+Add worker services with the same image, environment, and volumes as the existing
+`queue` service. Change only the command and healthcheck. Docker Compose example:
+
+```yaml
+services:
+  telematics-queue:
+    image: fleetbase/fleetbase-api:latest
+    command: ["php", "artisan", "queue:work", "--queue=telematics", "--sleep=1", "--max-time=3600"]
+    restart: unless-stopped
+    deploy:
+      replicas: 2
+    # environment, volumes and depends_on: copy from the existing `queue` service
+
+  telematics-broadcast-queue:
+    image: fleetbase/fleetbase-api:latest
+    command: ["php", "artisan", "queue:work", "--queue=telematics-broadcasts", "--sleep=1", "--max-time=3600"]
+    restart: unless-stopped
+    # environment, volumes and depends_on: copy from the existing `queue` service
+```
+
+Notes:
+
+- Leave the existing `queue` service unchanged. `queue:work` without `--queue`
+  processes the connection's default queue (`REDIS_QUEUE`, normally `default`).
+- Leave `--timeout` at its default (60 seconds) or set any value below the Redis
+  connection's `retry_after` (90 seconds). Polls (80 seconds) and ingestion
+  (60 seconds) define their own timeouts, which override the worker setting.
+  Broadcast jobs use the worker value.
+- `--max-time` recycles long-running workers so they pick up deployments and release
+  memory. `restart: unless-stopped` starts them again.
+- On Kubernetes, ECS, or another platform, create equivalent deployments with the
+  same image, environment, and commands.
+- Every worker container needs the same `APP_KEY`, database, Redis, and broadcasting
+  settings as the application. Deliveries are encrypted with `APP_KEY`.
+
+### 2. Set the queue variables for this instance only
+
+Add these to the environment of the application, scheduler, **and every queue
+worker** container. The scheduler dispatches polls and the application dispatches
+manual syncs, so every process must agree on the queue names:
+
+```dotenv
+TELEMATICS_POLL_QUEUE=telematics
+TELEMATICS_INGESTION_QUEUE=telematics
+TELEMATICS_BROADCAST_QUEUE=telematics-broadcasts
+```
+
+To use one worker type for all telematics work, set all three to `telematics` and
+omit the broadcast worker.
+
+AFAQY polls and ingestion also read `AFAQY_POLL_QUEUE` and `AFAQY_INGESTION_QUEUE`.
+Those take precedence over the `TELEMATICS_*` values when set, so remove or align
+them. Legacy discovery and connection-test jobs always use `TELEMATICS_POLL_QUEUE`.
+
+### 3. Deploy the change
+
+1. Deploy the new worker containers and confirm they are running.
+2. Apply the environment variables to the application, scheduler, and workers.
+3. If configuration is cached, rebuild it with `php artisan config:cache` in each
+   container, or through the normal image/deploy process.
+4. Restart long-running processes so they read the new configuration:
+   `php artisan queue:restart`, then reload Octane (`php artisan octane:reload`)
+   if the application runs under Octane.
+
+### 4. Existing backlog on `default`
+
+Jobs already on `default` stay there, and the existing worker must process them.
+The new setting affects only newly dispatched jobs.
+
+- Do not run `php artisan queue:clear` on `default`. It deletes every pending job,
+  including non-telematics work.
+- For opted-in batch providers such as Safee, a queued `SyncTelematicDevicesJob`
+  hands off to bounded polling and exits within seconds.
+- Queued legacy discovery jobs for other providers can each occupy the default
+  worker for a long time. If the backlog does not drain, inspect those specific
+  jobs rather than clearing the entire queue.
+
+## Sizing
+
+Start with **2 telematics workers and 1 broadcast worker**, then adjust based on
+queue depth.
+
+Current work per connection:
+
+- One poll per connection per minute, coalesced while its previous sweep is still
+  ingesting. Safee requests at most 1,000 vehicle IDs per `last-state` call.
+- Up to `ceil(units / TELEMATICS_BATCH_SIZE)` ingestion jobs per sweep (default
+  100 units per job). A fleet of about 470 reporting devices is about 5 ingestion
+  jobs per minute.
+- Workers can process different connections, deliveries, and devices concurrently.
+  Per-connection and per-device locks prevent duplicate polling or out-of-order
+  position updates.
+
+For reference, a local single-worker run for 93 Safee units applied each delivery in
+about 5-8 seconds (about 55-85 ms per unit), including database work. This was a
+development machine, not production. Measure production queue depth rather than
+extrapolating this value.
+
+Additional workers do not increase provider limits. Safee connections share a limit
+of 50 requests per second per account across all workers.
+
+## Verification
+
+Queue depth should stay close to zero between minute ticks:
+
+```bash
+php artisan queue:monitor redis:default,redis:telematics,redis:telematics-broadcasts --max=500
+```
+
+Also verify:
+
+- `telematic_sync_runs` for the connection shows a new `completed` run about once
+  per minute. `incomplete` means the fetch failed and will retry.
+- The worker logs show `PollTelematicTelemetry` and `ProcessTelematicDelivery` only
+  on the telematics workers, and broadcast jobs only on the broadcast worker.
+- Other jobs on `default`, such as notifications and order events, start promptly
+  again.
+
+## Rollback
+
+1. Remove the three variables from the application, scheduler, and workers, rebuild
+   cached configuration, and restart processes as in setup step 3.
+2. Keep the telematics workers running until `telematics` and
+   `telematics-broadcasts` are empty. Jobs remaining on those queues are not moved
+   back to `default`.
+3. Remove the worker containers.

package/docs/TELEMETRY_ARCHITECTURE.md

@@ -0,0 +1,115 @@
+# Provider-neutral telemetry infrastructure
+
+## Context and correction
+
+Fleet-Ops consumes third-party telematics through `TelematicProviderRegistry`,
+`TelematicProviderDescriptor`, and `TelematicProviderInterface`. Provider identity
+belongs at registration and adapter boundaries. Commit 9f561352 incorrectly
+extended AFAQY identity into shared resource components, map processing, and
+persistence. The performance requirement did not justify those dependencies.
+
+## Boundaries
+
+- Keep the existing provider interface compatible. Add an optional telemetry
+  interface for adapters opting into durable position ingestion and reconciliation.
+- Adapters interpret external identities, payload envelopes, timestamps, sensors,
+  authentication, rate limits, and reporting configuration. They return normalized
+  device/event/sensor samples. Shared workers never inspect vendor payload fields.
+- Use shared `telematic_sync_runs`, `telematic_deliveries`, and
+  `telematic_webhook_credentials` tables, scoped by `telematic_uuid`; the existing
+  connection identifies the provider and company. Do not create per-provider tables.
+- Shared services implement durable receipt, retries, replay, retention, ordering,
+  and diagnostics. Resolve adapters through the existing registry. Existing
+  providers retain their existing path until they implement the optional interface.
+- Declare UI capabilities in the existing provider descriptor. Shared connection
+  components render a reusable telemetry panel only when that capability is present.
+  Registration instructions and provider names are descriptor data, not template
+  branches. A registry of provider-specific components is unnecessary for the
+  currently identical diagnostics and registration UI.
+- Devices expose a normalized `meta.telemetry` snapshot. Maps consume a normalized
+  source timestamp from location events; neither knows which adapter produced it.
+- Keep provider configuration and public webhook URLs compatible. The original
+  migration has not been deployed or applied, as confirmed by the maintainer.
+  Replace it directly with the generic migration; no compatibility tables, rename
+  migration, or old job aliases are required. Existing pre-feature device metadata
+  remains readable through its established position timestamp fallback.
+
+## Review checks
+
+1. No provider-name branches in shared frontend components or movement tracking.
+2. Shared workers and ingestion accept a second registered adapter without edits.
+3. Unsupported providers expose no new telemetry UI or receiver capabilities.
+4. Storage, secret lookup, replay, and broadcasts remain connection/tenant scoped.
+5. Fresh installs create only generic infrastructure tables; rollback preserves
+   core device and integration tables.
+6. Polling/push deduplication, UTC timing, partial updates, ordering, and recovery
+   remain covered independently of the AFAQY adapter contract tests.
+
+## Tradeoffs
+
+Three shared tables separate run-level diagnostics, high-volume delivery retention,
+and connection-level secrets with different lifetimes. Provider-specific protocol
+classes remain appropriate. Capability opt-in avoids silently changing every
+existing integration's ingestion or webhook behavior. Production throughput and
+real AFAQY payload verification remain separate deployment gates.
+
+## Adding an adapter
+
+Implement `TelemetryProviderInterface` alongside the existing provider contract.
+`telemetryUnits()` recognizes the adapter's inbound envelope; it must also accept
+arrays of its raw samples for queued poll batches and failed-item retries.
+`normalizeTelemetrySnapshot()` returns `device`, `event`, and `sensors` using the
+existing normalization fields. `event.occurred_at` is device time,
+`event.last_seen_at` is provider contact time, and
+`event.meta.telemetry.provider_at` preserves the provider timestamp. No adapter
+normalization method may authenticate or perform network I/O.
+
+Register the driver with `TelematicProviderRegistry`, and declare
+`metadata.telemetry.durable_ingestion`, `secure_webhooks`, and `reconciliation`
+as appropriate. Optional `registration_instructions` and `contract_status`
+control explanatory UI copy. `telemetryOptions()` supplies adapter overrides for
+the shared `telematics.telemetry` configuration. Enabling an adapter does not
+require new tables, jobs, frontend components, or map branches.
+
+The example adapter in the database tests uses `tracker`, `measured`, `received`,
+and `point` fields and a `signals` envelope. It exercises shared poll and webhook
+processing, connection-scoped authentication, deduplication, and independent
+freshness settings without inheriting the AFAQY adapter.
+
+
+## Review and validation — 2026-09-16
+
+The refactor was checked against the boundaries above, then exercised through a
+second adapter. That feedback exposed numeric-cursor assumptions in the polling
+worker, provider registration failures interrupting shared inbox maintenance, and
+UI monitoring failing to start when capabilities arrived after the initial render.
+The shared paths now handle opaque cursors, isolate unavailable registrations
+while continuing recovery/retention, and restart monitoring on capability changes.
+
+Selected backend checks cover existing provider contracts and lifecycle behavior,
+database ingestion, poll/push deduplication, reversed delivery order, partial
+sensor values, tenant scoping, recovery, and migration up/down. The second adapter
+uses the same jobs, storage, receiver, and ingestion service without AFAQY
+inheritance or authentication during normalization. Source checks find no AFAQY
+identity in shared frontend components, map processing, telemetry workers,
+telemetry controllers, or the shared ingestion service.
+
+The location broadcast's additive `position_at` field is now asserted for a legacy
+provider too. It allows every adapter's map updates to use source time. The
+existing provider interface and legacy ingestion path remain available.
+
+Current functional checks: 105 selected backend tests pass; PHP syntax, ESLint,
+and template lint pass. The test-environment build succeeds. Five focused browser
+cases pass all 19 assertions against that build. Browser cases ran in fresh Chrome
+pages because the linked dummy host cannot recreate its universe registry across
+rendering tests; the standard launcher also has a Testem/execa module mismatch.
+These results do not establish a clean full browser suite or production socket
+latency.
+
+The opt-in local SQLite load gate remains open. The refactored path processed
+5,000 signals plus 5,000 duplicate reconciliation observations in 66.5 seconds,
+above its 60-second assertion. An earlier concurrent-build run took 109.2 seconds;
+the original commit, loaded from a temporary checkout with the same dependencies,
+took 83.4 seconds. Varying machine/build load prevents treating these runs as a
+controlled speed comparison. Each run retained exactly 5,000 events. Do not claim
+production throughput or the polling/webhook latency targets from these results.

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.65",
+    "version": "0.6.67",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.6.65",
+    "version": "0.6.67",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -45,8 +45,8 @@
     "dependencies": {
         "@babel/core": "^7.23.2",
         "@fleetbase/ember-core": "^0.3.24",
-        "@fleetbase/ember-ui": "^0.3.41",
-        "@fleetbase/fleetops-data": "^0.1.40",
+        "@fleetbase/ember-ui": "^0.4.1",
+        "@fleetbase/fleetops-data": "^0.2.1",
         "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",

package/scripts/coverage-summary.php

@@ -84,6 +84,13 @@ foreach ($project->xpath('.//file') ?: [] as $file) {
         continue;
     }
 
+    $uncoveredLines = [];
+    foreach ($file->line as $line) {
+        if ((string) $line['type'] === 'stmt' && (int) $line['count'] === 0) {
+            $uncoveredLines[] = (int) $line['num'];
+        }
+    }
+
     $files[] = [
         'path'            => $path,
         'covered'         => $coveredFileLines,
@@ -91,6 +98,7 @@ foreach ($project->xpath('.//file') ?: [] as $file) {
         'methods'         => $fileMethods,
         'covered_methods' => $coveredFileMethod,
         'percent'         => coveragePercent($coveredFileLines, $fileStatements),
+        'uncovered_lines' => $uncoveredLines,
     ];
 
     $relativePath = preg_replace('#^' . preg_quote(getcwd(), '#') . '/?#', '', $path);
@@ -141,6 +149,9 @@ echo "\nLowest covered files:\n";
 foreach (array_slice($files, 0, 20) as $file) {
     $relativePath = preg_replace('#^' . preg_quote(getcwd(), '#') . '/?#', '', $file['path']);
     printf("  %6.2f%%  %5d/%-5d  %s\n", $file['percent'], $file['covered'], $file['statements'], $relativePath ?: $file['path']);
+    if ($file['uncovered_lines']) {
+        printf("            Uncovered lines: %s\n", implode(', ', $file['uncovered_lines']));
+    }
 }
 
 if ($failUnder !== null && coveragePercent($coveredStatements, $statements) < $failUnder) {

package/scripts/pest-bootstrap.php

@@ -328,7 +328,7 @@ if (!class_exists('Fleetbase\TestSupport\PendingDispatch')) {
 }
 
 if (!class_exists('Fleetbase\TestSupport\DispatchRecorder')) {
-    eval('namespace Fleetbase\TestSupport; class DispatchRecorder { public static array $dispatched = []; public static function record(string $job, array $arguments): void { self::$dispatched[] = [\'job\' => $job, \'arguments\' => $arguments]; } }');
+    eval('namespace Fleetbase\TestSupport; class DispatchRecorder { public static array $dispatched = []; public static ?\Throwable $failure = null; public static function record(string $job, array $arguments): void { if (self::$failure) { throw self::$failure; } self::$dispatched[] = [\'job\' => $job, \'arguments\' => $arguments]; } }');
 }
 
 if (!trait_exists('Illuminate\Foundation\Bus\Dispatchable')) {

package/server/config/afaqy.php

@@ -0,0 +1,8 @@
+<?php
+
+return [
+    'polling_enabled'           => env('AFAQY_POLLING_ENABLED', false),
+    'webhooks_enabled'          => env('AFAQY_WEBHOOKS_ENABLED', false),
+    'poll_queue'                => env('AFAQY_POLL_QUEUE', env('TELEMATICS_POLL_QUEUE', 'default')),
+    'ingestion_queue'           => env('AFAQY_INGESTION_QUEUE', env('TELEMATICS_INGESTION_QUEUE', 'default')),
+];

package/server/config/fuel-providers.php

@@ -14,11 +14,30 @@ return [
             'required_fields' => [
                 [
                     'name' => 'api_token',
-                    'label' => 'API Token',
+                    'label' => 'Integration Token (WS-SK) or API Token',
                     'type' => 'password',
-                    'help_text' => 'Bearer API token from PetroApp.',
+                    'help_text' => 'Use the test token for Sandbox, or your company token for Production. Select the matching authentication method.',
                     'required' => true,
                 ],
+                [
+                    'name' => 'auth_type',
+                    'label' => 'Authentication method',
+                    'type' => 'select',
+                    'default' => 'ws_sk_header',
+                    'options' => [
+                        ['value' => 'ws_sk_header', 'label' => 'Integration Token (WS-SK)'],
+                        ['value' => 'bearer_token', 'label' => 'Bearer API Token'],
+                    ],
+                    'help_text' => 'Choose WS-SK for an integration token, or Bearer for a token returned by get_apiKey.',
+                    'required' => false,
+                ],
+                [
+                    'name' => 'base_url',
+                    'label' => 'Base URL override (optional)',
+                    'type' => 'url',
+                    'help_text' => 'Leave blank to use the selected environment. A custom URL overrides the environment selection.',
+                    'required' => false,
+                ],
             ],
             'capabilities' => ['vehicles', 'transactions', 'stations', 'trips'],
             'sync_defaults' => [
@@ -27,13 +46,15 @@ return [
                 'auto_create_fuel_reports' => true,
             ],
             'setup_instructions' => [
-                'Create or request a PetroApp API token.',
-                'Enter the token, then run Test Connection.',
-                'Run a date-window sync to import bills into Fuel Transactions.',
+                'Select Sandbox for PetroApp staging and enter the test integration token using WS-SK authentication.',
+                'Run Test Connection, then sync a small date window to verify imported bills and vehicle matches.',
+                'For Production, use your company integration token from the PetroApp API token profile page.',
+                'Alternatively, exchange company username and password at get_apiKey and use the returned Bearer API token.',
             ],
             'metadata' => [
-                'auth_type' => 'bearer_token',
-                'legacy_auth_type' => 'ws_sk_header',
+                'auth_type' => 'ws_sk_header',
+                'supported_auth_types' => ['ws_sk_header', 'bearer_token'],
+                'base_urls' => \Fleetbase\FleetOps\Support\FuelProviders\Providers\PetroAppFuelProvider::BASE_URLS,
                 'pagination' => 'page',
                 'default_currency' => 'SAR',
             ],

package/server/config/safee.php

@@ -0,0 +1,10 @@
+<?php
+
+return [
+    'polling_enabled'            => env('SAFEE_POLLING_ENABLED', true),
+    'webhooks_enabled'           => false,
+    'manual_batch_sync'          => true,
+    'page_size'                  => 1000,
+    'inventory_cache_seconds'    => env('SAFEE_INVENTORY_CACHE_SECONDS', 300),
+    'request_timeout_seconds'    => env('SAFEE_REQUEST_TIMEOUT_SECONDS', 30),
+];

package/server/config/telematics.php

@@ -153,9 +153,16 @@ return [
                     'validation'  => 'required_without:username|string',
                 ],
             ],
-            'supports_webhooks'  => false,
+            'supports_webhooks'  => true,
             'supports_discovery' => true,
             'metadata'           => [
+                'telemetry' => [
+                    'durable_ingestion'         => true,
+                    'secure_webhooks'           => true,
+                    'reconciliation'            => true,
+                    'registration_instructions' => 'Provide the secure URL to AFAQY to register Device Signals / Positions. Polling continues after registration.',
+                    'contract_status'           => 'provisional',
+                ],
                 'rate_limit'   => 60,
                 'pagination'   => 'offset',
                 'capabilities' => ['tracking', 'speed', 'heading', 'odometer', 'fuel_level', 'ignition'],
@@ -169,6 +176,7 @@ return [
             'driver_class'    => Fleetbase\FleetOps\Support\Telematics\Providers\SafeeProvider::class,
             'icon'            => '/engines-dist/images/telematics/providers/safee.webp',
             'description'     => 'Safee Tracking REST integration for vehicle discovery, last state, live positions, odometer, fuel, and sensor data.',
+            'docs_url'        => 'https://www.safee.com/_docs_/Safee_Tracking_REST_Service.pdf',
             'required_fields' => [
                 [
                     'name'          => 'server_uri',
@@ -222,7 +230,13 @@ return [
             'supports_discovery' => true,
             'metadata'           => [
                 'rate_limit'   => 3000,
-                'pagination'   => 'none',
+                'rate_limit_per_second' => 50,
+                'pagination'   => 'inventory_cursor',
+                'telemetry'    => [
+                    'durable_ingestion' => true,
+                    'secure_webhooks'   => false,
+                    'reconciliation'    => true,
+                ],
                 'capabilities' => ['tracking', 'speed', 'heading', 'odometer', 'fuel_level', 'ignition'],
             ],
         ],

package/server/config/telemetry.php

@@ -0,0 +1,20 @@
+<?php
+
+return [
+    'polling_enabled'           => false,
+    'webhooks_enabled'          => false,
+    'poll_queue'                => env('TELEMATICS_POLL_QUEUE', 'default'),
+    'ingestion_queue'           => env('TELEMATICS_INGESTION_QUEUE', 'default'),
+    // Null keeps telemetry broadcasts on the connection's default queue.
+    'broadcast_queue'           => env('TELEMATICS_BROADCAST_QUEUE'),
+    'page_size'                 => 1000,
+    'max_pages'                 => 100,
+    'request_timeout_seconds'   => env('TELEMATICS_REQUEST_TIMEOUT_SECONDS', 45),
+    'batch_size'                => env('TELEMATICS_BATCH_SIZE', 100),
+    'max_payload_bytes'         => 2097152,
+    'max_pending_deliveries'    => 10000,
+    'processed_retention_hours' => 24,
+    'quarantine_retention_days' => 7,
+    'stale_engine_on_seconds'   => 120,
+    'stale_engine_off_seconds'  => 600,
+];