Add resource limits

Author: snazy

README.md

@@ -23,6 +23,7 @@ and failure handling.
   - [Authorization expressions](docs/guides/authorization.md)
   - [Custom functions](docs/guides/custom-functions.md)
 - [Advanced use](docs/index.md#advanced-use)
+  - [Resource controls and cancellation](docs/advanced/resource-controls-and-cancellation.md)
 - [Internals and optimization](docs/index.md#internals)
   - [Optimization mechanisms](docs/internals/optimization-mechanisms.md)
   - [Native evaluation](docs/internals/native-evaluation.md)
@@ -141,12 +142,15 @@ generated Java, generated bytecode, JNI, or CPU-native compiled expressions. See
 
 CEL restricts side effects and general recursion, but an expression can still be expensive for
 large inputs or through comprehensions, regular expressions, and custom functions. CEL-Java
-provides parser recursion and source-size limits; it does not currently provide a general
-evaluation time, step, memory, or comprehension-iteration budget.
-
-Applications accepting untrusted expressions or inputs must apply their own admission policy,
-input-size limits, execution isolation or deadlines, and fail-closed handling appropriate to the
-use case. See [Compatibility and limitations](docs/reference/compatibility-and-limitations.md).
+provides cooperative cancellation, elapsed and executing-thread CPU/allocation budgets, structural
+AST admission, and parser recursion/source-size limits. These controls are not process isolation
+and do not preempt arbitrary host callbacks.
+
+Applications accepting untrusted expressions or inputs should combine those controls with an
+admission policy, bounded inputs and functions, deployment isolation, and fail-closed handling
+appropriate to the use case. See
+[Resource controls and cancellation](docs/advanced/resource-controls-and-cancellation.md) and
+[Compatibility and limitations](docs/reference/compatibility-and-limitations.md).
 
 Report vulnerabilities according to the [security policy](SECURITY.md).
 

core/src/jmh/java/org/projectnessie/cel/CompileBuildBench.java

@@ -81,6 +81,22 @@ public void envCompileAndProgram(CompileState state, Blackhole blackhole) {
     blackhole.consume(env.program(ast.getAst()));
   }
 
+  @Benchmark
+  public void envControlledCompileAndProgram(CompileState state, Blackhole blackhole) {
+    Env env =
+        newEnv(
+            declarations(
+                Decls.newVar("resource", Decls.String),
+                Decls.newVar("user", Decls.String),
+                Decls.newVar("request", Decls.Dyn),
+                Decls.newVar("items", Decls.newListType(Decls.Dyn))));
+    AstIssuesTuple ast = env.compileCancelable(state.source()).execute();
+    if (ast.hasIssues()) {
+      throw ast.getIssues().err();
+    }
+    blackhole.consume(env.programCancelable(ast.getAst()).execute());
+  }
+
   @Benchmark
   public void scriptCompilerBuild(CompileState state, Blackhole blackhole) throws Exception {
     Script script =

core/src/jmh/java/org/projectnessie/cel/EvaluatorBaselineBench.java

@@ -23,9 +23,12 @@
 import static org.projectnessie.cel.interpreter.Activation.newActivation;
 
 import dev.cel.expr.conformance.proto3.TestAllTypes;
+import java.time.Duration;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
+import java.util.stream.LongStream;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -61,7 +64,8 @@ public static class EvaluationState {
       "chainString",
       "shortCircuit",
       "mapSelection",
-      "protoSelection"
+      "protoSelection",
+      "longQuantifier"
     })
     public String expression;
 
@@ -71,6 +75,9 @@ public static class EvaluationState {
     Activation activation;
     Class<?> nativeResultType;
     Supplier<Object> nativeJava;
+    ResourceLimits elapsedLimit;
+    ResourceLimits cpuLimit;
+    ResourceLimits allocationLimit;
 
     @Setup
     public void init() {
@@ -159,6 +166,14 @@ public void init() {
           nativeResultType = Boolean.class;
           nativeJava = () -> message.getSingleInt64() == (long) variables.get("target");
           break;
+        case "longQuantifier":
+          env = newEnv(declarations(Decls.newVar("values", Decls.newListType(Decls.Int))));
+          source = "values.exists(x, x == -1)";
+          List<Long> values = LongStream.range(0, 1_000).boxed().toList();
+          variables = Map.of("values", values);
+          nativeResultType = Boolean.class;
+          nativeJava = () -> values.stream().noneMatch(value -> value == -1);
+          break;
         default:
           throw new IllegalArgumentException(
               "Unknown evaluator benchmark expression: " + expression);
@@ -171,6 +186,9 @@ public void init() {
       program = env.program(ast.getAst(), evalOptions(OptOptimize));
       internalProgram = (Prog) program;
       activation = newActivation(variables);
+      elapsedLimit = ResourceLimits.newBuilder().elapsedTimeLimit(Duration.ofSeconds(1)).build();
+      cpuLimit = ResourceLimits.newBuilder().cpuTimeLimit(Duration.ofSeconds(1)).build();
+      allocationLimit = ResourceLimits.newBuilder().allocatedBytesLimit(1_000_000).build();
     }
   }
 
@@ -184,6 +202,26 @@ public Program.EvalResult programEval(EvaluationState state) {
     return state.program.eval(state.variables);
   }
 
+  @Benchmark
+  public Program.EvalResult programEvalCancellationOnly(EvaluationState state) {
+    return state.program.evalCancelable(state.variables).eval();
+  }
+
+  @Benchmark
+  public Program.EvalResult programEvalElapsedLimit(EvaluationState state) {
+    return state.program.evalCancelable(state.variables, state.elapsedLimit).eval();
+  }
+
+  @Benchmark
+  public Program.EvalResult programEvalCpuLimit(EvaluationState state) {
+    return state.program.evalCancelable(state.variables, state.cpuLimit).eval();
+  }
+
+  @Benchmark
+  public Program.EvalResult programEvalAllocationLimit(EvaluationState state) {
+    return state.program.evalCancelable(state.variables, state.allocationLimit).eval();
+  }
+
   @Benchmark
   public Object programEvalNative(EvaluationState state) {
     return state.internalProgram.e.adapter.valueToNative(

core/src/main/congocc/cel/cel-java.ccc

@@ -23,6 +23,11 @@ INCLUDE "cel.ccc"
 
 INJECT PARSER_CLASS :
 {
+  private void resourceCheckpoint() {
+    org.projectnessie.cel.internal.OperationCheckpoints.currentController().checkpoint(
+        org.projectnessie.cel.OperationAbortedException.Phase.PARSE);
+  }
+
   private boolean nextTokenStartsExpression() {
     TokenType type = getToken(1).getType();
     return switch (type) {

core/src/main/congocc/cel/cel.ccc

@@ -16,9 +16,10 @@
 
 INCLUDE "cel-lexer.ccc"
 
-Start : Expr! <EOF>! ;
+Start : { resourceCheckpoint(); } Expr! <EOF>! ;
 
 Expr :
+  { resourceCheckpoint(); }
   ConditionalOr
   [<QUESTIONMARK> ConditionalOr <COLON> Expr]
   ;
@@ -44,12 +45,13 @@ Multiplicative :
   ;
 
 Unary :
-  (<EXCLAM> | <MINUS>)* Member
+  ({ resourceCheckpoint(); } (<EXCLAM> | <MINUS>))* Member
   ;
 
 Member :
   Primary
   (
+    { resourceCheckpoint(); }
     <DOT> [<QUESTIONMARK>] Field [<LPAREN> (<RPAREN> | ExprList <RPAREN>)]
   | <LBRACKET> [<QUESTIONMARK>] Expr <RBRACKET>
   | <LBRACE> [FieldInitializerList] [<COMMA>] <RBRACE>
@@ -65,15 +67,16 @@ Primary :
   ;
 
 ExprList :
-  Expr (<COMMA> Expr =>||)*!
+  Expr ({ resourceCheckpoint(); } <COMMA> Expr =>||)*!
   ;
 
 ListInitializerList :
-  [<QUESTIONMARK>] Expr (<COMMA> [<QUESTIONMARK>] Expr =>||)*!
+  [<QUESTIONMARK>] Expr ({ resourceCheckpoint(); } <COMMA> [<QUESTIONMARK>] Expr =>||)*!
   ;
 
 FieldInitializerList :
-  [<QUESTIONMARK>] Field <COLON> Expr (<COMMA> [<QUESTIONMARK>] Field <COLON> Expr =>||)*!
+  [<QUESTIONMARK>] Field <COLON> Expr
+  ({ resourceCheckpoint(); } <COMMA> [<QUESTIONMARK>] Field <COLON> Expr =>||)*!
   ;
 
 Field :
@@ -82,7 +85,8 @@ Field :
   ;
 
 MapInitializerList :
-  [<QUESTIONMARK>] Expr <COLON> Expr (<COMMA> [<QUESTIONMARK>] Expr <COLON> Expr =>||)*!
+  [<QUESTIONMARK>] Expr <COLON> Expr
+  ({ resourceCheckpoint(); } <COMMA> [<QUESTIONMARK>] Expr <COLON> Expr =>||)*!
   ;
 
 ConstantLiteral :

core/src/main/java/org/projectnessie/cel/AstAdmission.java

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2026 The Authors of CEL-Java
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.projectnessie.cel;
+
+import com.google.api.expr.v1alpha1.Expr;
+import java.util.ArrayDeque;
+import org.projectnessie.cel.OperationAbortedException.Phase;
+import org.projectnessie.cel.OperationAbortedException.Reason;
+import org.projectnessie.cel.OperationAbortedException.Resource;
+import org.projectnessie.cel.internal.OperationController;
+
+/** Iterative structural admission for controlled AST operations. */
+final class AstAdmission {
+  private AstAdmission() {}
+
+  static void check(Ast ast, OperationController controller, Phase phase) {
+    var limits = controller.limits();
+    if (limits.astNodes() >= 0 || limits.astDepth() >= 0) {
+      checkTree(ast.getExpr(), controller, phase, limits.astNodes(), limits.astDepth());
+    }
+    if (limits.astMetadataEntries() >= 0) {
+      long entries = 0;
+      var info = ast.getSourceInfo();
+      if (info != null) {
+        entries = add(entries, info.getPositionsCount(), limits.astMetadataEntries(), phase);
+        entries = add(entries, info.getLineOffsetsCount(), limits.astMetadataEntries(), phase);
+        entries = add(entries, info.getMacroCallsCount(), limits.astMetadataEntries(), phase);
+        for (Expr macro : info.getMacroCallsMap().values()) {
+          entries =
+              checkMetadataTree(macro, controller, phase, entries, limits.astMetadataEntries());
+        }
+      }
+      entries = add(entries, ast.refMap.size(), limits.astMetadataEntries(), phase);
+      add(entries, ast.typeMap.size(), limits.astMetadataEntries(), phase);
+    }
+  }
+
+  private static long checkTree(
+      Expr root, OperationController controller, Phase phase, long nodeLimit, int depthLimit) {
+    var pending = new ArrayDeque<NodeDepth>();
+    pending.push(new NodeDepth(root, 1));
+    long count = 0;
+    while (!pending.isEmpty()) {
+      controller.checkpoint(phase);
+      var current = pending.pop();
+      count++;
+      if (nodeLimit >= 0 && count > nodeLimit) {
+        throw limit(Reason.AST_NODE_LIMIT, phase, Resource.AST_NODES, nodeLimit, count);
+      }
+      if (depthLimit >= 0 && current.depth > depthLimit) {
+        throw limit(Reason.AST_DEPTH_LIMIT, phase, Resource.AST_DEPTH, depthLimit, current.depth);
+      }
+      pushChildren(current.expr, current.depth + 1, pending);
+    }
+    return count;
+  }
+
+  private static long checkMetadataTree(
+      Expr root,
+      OperationController controller,
+      Phase phase,
+      long initialCount,
+      long metadataLimit) {
+    var pending = new ArrayDeque<Expr>();
+    pending.push(root);
+    long count = initialCount;
+    while (!pending.isEmpty()) {
+      controller.checkpoint(phase);
+      var current = pending.pop();
+      count = add(count, 1, metadataLimit, phase);
+      pushMetadataChildren(current, pending);
+    }
+    return count;
+  }
+
+  private static void pushChildren(Expr expr, int depth, ArrayDeque<NodeDepth> pending) {
+    switch (expr.getExprKindCase()) {
+      case SELECT_EXPR -> pending.push(new NodeDepth(expr.getSelectExpr().getOperand(), depth));
+      case CALL_EXPR -> {
+        var call = expr.getCallExpr();
+        for (Expr arg : call.getArgsList()) {
+          pending.push(new NodeDepth(arg, depth));
+        }
+        if (call.hasTarget()) {
+          pending.push(new NodeDepth(call.getTarget(), depth));
+        }
+      }
+      case LIST_EXPR -> {
+        for (Expr element : expr.getListExpr().getElementsList()) {
+          pending.push(new NodeDepth(element, depth));
+        }
+      }
+      case STRUCT_EXPR -> {
+        for (var entry : expr.getStructExpr().getEntriesList()) {
+          pending.push(new NodeDepth(entry.getValue(), depth));
+          if (entry.hasMapKey()) {
+            pending.push(new NodeDepth(entry.getMapKey(), depth));
+          }
+        }
+      }
+      case COMPREHENSION_EXPR -> {
+        var comprehension = expr.getComprehensionExpr();
+        pending.push(new NodeDepth(comprehension.getIterRange(), depth));
+        pending.push(new NodeDepth(comprehension.getAccuInit(), depth));
+        pending.push(new NodeDepth(comprehension.getLoopCondition(), depth));
+        pending.push(new NodeDepth(comprehension.getLoopStep(), depth));
+        pending.push(new NodeDepth(comprehension.getResult(), depth));
+      }
+      default -> {
+        // Scalar expression.
+      }
+    }
+  }
+
+  private static void pushMetadataChildren(Expr expr, ArrayDeque<Expr> pending) {
+    switch (expr.getExprKindCase()) {
+      case SELECT_EXPR -> pending.push(expr.getSelectExpr().getOperand());
+      case CALL_EXPR -> {
+        var call = expr.getCallExpr();
+        pending.addAll(call.getArgsList());
+        if (call.hasTarget()) {
+          pending.push(call.getTarget());
+        }
+      }
+      case LIST_EXPR -> pending.addAll(expr.getListExpr().getElementsList());
+      case STRUCT_EXPR -> {
+        for (var entry : expr.getStructExpr().getEntriesList()) {
+          pending.push(entry.getValue());
+          if (entry.hasMapKey()) {
+            pending.push(entry.getMapKey());
+          }
+        }
+      }
+      case COMPREHENSION_EXPR -> {
+        var comprehension = expr.getComprehensionExpr();
+        pending.push(comprehension.getIterRange());
+        pending.push(comprehension.getAccuInit());
+        pending.push(comprehension.getLoopCondition());
+        pending.push(comprehension.getLoopStep());
+        pending.push(comprehension.getResult());
+      }
+      default -> {
+        // Scalar expression.
+      }
+    }
+  }
+
+  private static long add(long value, long increment, long limit, Phase phase) {
+    var observed = value + increment;
+    if (observed < value) {
+      observed = Long.MAX_VALUE;
+    }
+    if (observed > limit) {
+      throw limit(Reason.AST_METADATA_LIMIT, phase, Resource.AST_METADATA_ENTRIES, limit, observed);
+    }
+    return observed;
+  }
+
+  private static OperationAbortedException limit(
+      Reason reason, Phase phase, Resource resource, long limit, long observed) {
+    return new OperationAbortedException(reason, phase, resource, limit, observed);
+  }
+
+  private record NodeDepth(Expr expr, int depth) {}
+}