Rules engine API performance degrades when evaluating complex conditions with 100+ rule sets

IOT Cisco IoT Cloud Connect
, , , , , , , ,
1

Our automation workflows using Cisco IoT Cloud Connect v25 Rules Engine API are experiencing severe performance degradation. Response time increased from 50ms to 3-5 seconds when evaluating rules with complex conditions (10+ predicates with nested AND/OR logic). We have 200 active rules checking telemetry from 1000 devices every 30 seconds.


Rule: IF (temp > 75 AND humidity > 60) OR (temp > 85)
      AND (location = 'warehouse-A' OR location = 'warehouse-B')
      AND time_of_day BETWEEN '08:00' AND '18:00'
      THEN trigger_alert

Evaluation time: 3.2s per device (unacceptable)

This causes automation latency - alerts fire 2-3 minutes after threshold breaches. We suspect the engine re-evaluates all conditions for every telemetry update without caching. Are there rule compilation and caching optimizations? Would condition indexing help? Should we implement batch evaluation or parallel processing? Is edge rule deployment an option to reduce API load?

2

Yes, the batch evaluation endpoint is /api/v25/rules/evaluate/batch and it’s essential for your scale. Send telemetry for up to 100 devices in a single request, and the engine evaluates all applicable rules for all devices in one operation. This reduces API overhead by 99% and enables internal optimizations like parallel evaluation across devices. Your 30,000 API calls/min becomes 300 calls/min with 100-device batches.

3

We do have compileRules enabled, but I’m not sure about condition indexing - where do we configure that? Also, we’re currently calling the rules evaluation API once per device per telemetry update (1000 devices × 30 updates/min = 30,000 API calls/min). Is there a batch evaluation endpoint that can evaluate multiple devices in a single call?

4

Your performance issues stem from multiple architectural problems that need systematic resolution. Let me address each aspect comprehensively.

Rule Compilation and Caching: The v25 rules engine includes a sophisticated compilation system that converts declarative rules into optimized evaluation code. However, compilation must be explicitly triggered and results cached:

const compiledRules = await api.compileRules({
  ruleIds: ['rule-001', 'rule-002'],
  cachePolicy: 'aggressive',
  optimizationLevel: 'max'
});

Compiled rules are cached for 1 hour by default. With aggressive caching, this extends to 24 hours, reducing compilation overhead by 99%. Compilation converts your complex rule into an evaluation function:

// Before compilation (interpreted):
IF (temp > 75 AND humidity > 60) OR (temp > 85) ...

// After compilation (optimized function):
function evaluate(device) {
  if (device.temp > 85) return true;  // Short-circuit
  if (device.temp > 75 && device.humidity > 60) return true;
  // ... additional optimized conditions
}

Compiled evaluation is 50-100x faster than interpreted evaluation.

Condition Indexing: The rules engine maintains an in-memory index of device state for fast condition evaluation. Configure indexes on frequently queried fields:

api.createRuleIndex({
  fields: ['temp', 'humidity', 'location'],
  type: 'composite',
  indexStrategy: 'hash'
});

Without indexes, evaluating temp > 75 requires scanning all 1000 device states (O(n)). With indexes, it’s O(log n) lookup. For your workload, proper indexing reduces evaluation time from 3.2s to 50-100ms.

Critically, create composite indexes for AND conditions:

api.createRuleIndex({
  fields: ['temp', 'humidity'],  // Composite index
  type: 'composite'
});

This allows the engine to evaluate temp > 75 AND humidity > 60 with a single index lookup instead of two separate lookups plus intersection.

Batch Evaluation: Your current architecture (30,000 API calls/min) is the primary bottleneck. Switch to batch evaluation immediately:

const results = await api.evaluateRulesBatch({
  devices: deviceTelemetry.slice(0, 100),  // 100 devices
  rules: activeRuleIds,
  evaluationMode: 'parallel'
});

Batch evaluation provides:

  1. 99% reduction in API calls (30,000 → 300/min)
  2. Parallel evaluation across devices (8-16x speedup)
  3. Shared rule compilation (compile once, evaluate 100 devices)
  4. Reduced network overhead (one request instead of 100)

For your 1000 devices, use 10 batch requests with 100 devices each, reducing total evaluation time from 3200s (sequential) to 30-50s (batched parallel).

Parallel Processing: The rules engine supports parallel evaluation across multiple dimensions:

  1. Device Parallelism: Evaluate rules for multiple devices concurrently
  2. Rule Parallelism: Evaluate multiple independent rules concurrently
  3. Condition Parallelism: Evaluate independent conditions within a rule concurrently

Enable parallel processing:

api.configureRulesEngine({
  parallelism: {
    devices: 16,  // Evaluate 16 devices concurrently
    rules: 8,     // Evaluate 8 rules per device concurrently
    conditions: 4  // Evaluate 4 conditions per rule concurrently
  }
});

With 16-way device parallelism, your 1000-device evaluation completes in 1/16th the time (200s → 12s).

Edge Rule Deployment: For latency-sensitive automation, deploy rules to edge gateways:

api.deployRulesToEdge({
  gatewayIds: ['gateway-001', 'gateway-002'],
  ruleIds: ['temp-alert', 'humidity-alert'],
  evaluationFrequency: '1s'  // Evaluate every second at edge
});

Edge deployment provides:

  • Sub-second alert latency (evaluate locally, no cloud round-trip)
  • 80-90% reduction in cloud API load (only violations sent to cloud)
  • Continued operation during network outages
  • Bandwidth savings (transmit violations, not all telemetry)

For your temperature/humidity alerts, edge deployment reduces latency from 2-3 minutes to 1-2 seconds.

Recommended Architecture:

  1. Compile and cache all 200 rules with aggressive caching (24-hour TTL)
  2. Create composite indexes on (temp, humidity), (location, time_of_day)
  3. Switch to batch evaluation with 100-device batches (300 API calls/min instead of 30,000)
  4. Enable parallel processing with 16-way device parallelism
  5. Deploy critical rules to edge for sub-second latency on time-sensitive alerts

Expected performance improvements:

  • Evaluation time: 3.2s → 50ms per device (98% improvement)
  • Alert latency: 2-3 minutes → 1-2 seconds (99% improvement)
  • API load: 30,000 calls/min → 300 calls/min (99% reduction)
  • Cloud costs: 80-90% reduction from edge deployment

Implement these optimizations in order of impact: batch evaluation (immediate 99% API reduction), then indexing (98% latency reduction), then edge deployment (sub-second alerts). This will transform your rules engine from a performance bottleneck into a responsive automation platform.

5

Condition indexing is critical for rule performance. The engine needs indexes on frequently evaluated fields (temp, humidity, location). Without indexes, every rule evaluation requires full table scans of device state. Create composite indexes on common condition combinations: (temp, humidity), (location, time_of_day). This can reduce evaluation time by 90% for complex rules with multiple conditions.

6

For latency-sensitive automation, consider edge rule deployment. The v25 rules engine supports pushing compiled rules to edge gateways, where they evaluate telemetry locally before sending to cloud. This eliminates network round-trip latency (100-200ms) and reduces cloud API load by 80-90%. Only rule violations are sent to cloud, not all telemetry. Edge deployment is particularly effective for simple threshold rules like your temperature/humidity alerts.

7

The 3-5 second evaluation time for complex rules is definitely abnormal. The v25 rules engine should compile rules into optimized evaluation trees. Check if rule compilation is enabled in your configuration - there’s a compileRules parameter that must be set to true. Without compilation, the engine interprets rules on every evaluation, which is 100x slower. Also, ensure you’re using the batch evaluation endpoint rather than evaluating rules individually.