diff --git a/spec/datadog/appsec/contrib/graphql/reactive/multiplex_spec.rb b/spec/datadog/appsec/contrib/graphql/reactive/multiplex_spec.rb
index 519904cfc5d..21df7b7b6d5 100644
--- a/spec/datadog/appsec/contrib/graphql/reactive/multiplex_spec.rb
+++ b/spec/datadog/appsec/contrib/graphql/reactive/multiplex_spec.rb
@@ -4,14 +4,15 @@
 require 'datadog/tracing/contrib/graphql/support/application'
 
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
 require 'datadog/appsec/contrib/graphql/gateway/multiplex'
 require 'datadog/appsec/contrib/graphql/reactive/multiplex'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/reactive/shared_examples'
 
 RSpec.describe Datadog::AppSec::Contrib::GraphQL::Reactive::Multiplex do
   include_context 'with GraphQL multiplex'
 
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:expected_arguments) do
     {
       'user' => [{ 'id' => 1 }, { 'id' => 10 }],
@@ -20,10 +21,10 @@
   end
 
   describe '.publish' do
-    it 'propagates multiplex attributes to the operation' do
-      expect(operation).to receive(:publish).with('graphql.server.all_resolvers', expected_arguments)
+    it 'propagates multiplex attributes to the engine' do
+      expect(engine).to receive(:publish).with('graphql.server.all_resolvers', expected_arguments)
       gateway_multiplex = Datadog::AppSec::Contrib::GraphQL::Gateway::Multiplex.new(multiplex)
-      described_class.publish(operation, gateway_multiplex)
+      described_class.publish(engine, gateway_multiplex)
     end
   end
 
@@ -32,17 +33,17 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with(
+        expect(engine).to receive(:subscribe).with(
           'graphql.server.all_resolvers'
         ).and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         waf_result = double(:waf_result, status: :ok, timeout: false)
         expect(waf_context).to receive(:run).with(
@@ -50,9 +51,9 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
         gateway_multiplex = Datadog::AppSec::Contrib::GraphQL::Gateway::Multiplex.new(multiplex)
-        result = described_class.publish(operation, gateway_multiplex)
+        result = described_class.publish(engine, gateway_multiplex)
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/contrib/rack/reactive/request_body_spec.rb b/spec/datadog/appsec/contrib/rack/reactive/request_body_spec.rb
index 7b5ce95a3a2..75cf9aae480 100644
--- a/spec/datadog/appsec/contrib/rack/reactive/request_body_spec.rb
+++ b/spec/datadog/appsec/contrib/rack/reactive/request_body_spec.rb
@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
 require 'datadog/appsec/contrib/rack/gateway/request'
 require 'datadog/appsec/contrib/rack/reactive/request_body'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/reactive/shared_examples'
 
 require 'rack'
 
 RSpec.describe Datadog::AppSec::Contrib::Rack::Reactive::RequestBody do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:request) do
     Datadog::AppSec::Contrib::Rack::Gateway::Request.new(
       Rack::MockRequest.env_for(
@@ -20,10 +20,10 @@
   end
 
   describe '.publish' do
-    it 'propagates request body attributes to the operation' do
-      expect(operation).to receive(:publish).with('request.body', { 'foo' => 'bar' })
+    it 'propagates request body attributes to the engine' do
+      expect(engine).to receive(:publish).with('request.body', { 'foo' => 'bar' })
 
-      described_class.publish(operation, request)
+      described_class.publish(engine, request)
     end
   end
 
@@ -32,15 +32,15 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with('request.body').and_call_original
+        expect(engine).to receive(:subscribe).with('request.body').and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         expected_waf_arguments = { 'server.request.body' => { 'foo' => 'bar' } }
 
@@ -50,8 +50,8 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
-        result = described_class.publish(operation, request)
+        described_class.subscribe(engine, waf_context)
+        result = described_class.publish(engine, request)
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/contrib/rack/reactive/request_spec.rb b/spec/datadog/appsec/contrib/rack/reactive/request_spec.rb
index b9927ce8f87..f22a3964b1d 100644
--- a/spec/datadog/appsec/contrib/rack/reactive/request_spec.rb
+++ b/spec/datadog/appsec/contrib/rack/reactive/request_spec.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/contrib/rack/gateway/request'
 require 'datadog/appsec/contrib/rack/reactive/request'
 require 'datadog/appsec/reactive/shared_examples'
@@ -9,7 +9,7 @@
 require 'rack'
 
 RSpec.describe Datadog::AppSec::Contrib::Rack::Reactive::Request do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:request) do
     Datadog::AppSec::Contrib::Rack::Gateway::Request.new(
       Rack::MockRequest.env_for(
@@ -34,15 +34,15 @@
   end
 
   describe '.publish' do
-    it 'propagates request attributes to the operation' do
-      expect(operation).to receive(:publish).with('server.request.method', 'GET')
-      expect(operation).to receive(:publish).with('request.query', { 'a' => ['foo'] })
-      expect(operation).to receive(:publish).with('request.headers', expected_headers_with_cookies)
-      expect(operation).to receive(:publish).with('request.uri.raw', '/?a=foo')
-      expect(operation).to receive(:publish).with('request.cookies', { 'foo' => 'bar' })
-      expect(operation).to receive(:publish).with('request.client_ip', '10.10.10.10')
+    it 'propagates request attributes to the engine' do
+      expect(engine).to receive(:publish).with('server.request.method', 'GET')
+      expect(engine).to receive(:publish).with('request.query', { 'a' => ['foo'] })
+      expect(engine).to receive(:publish).with('request.headers', expected_headers_with_cookies)
+      expect(engine).to receive(:publish).with('request.uri.raw', '/?a=foo')
+      expect(engine).to receive(:publish).with('request.cookies', { 'foo' => 'bar' })
+      expect(engine).to receive(:publish).with('request.client_ip', '10.10.10.10')
 
-      described_class.publish(operation, request)
+      described_class.publish(engine, request)
     end
   end
 
@@ -51,7 +51,7 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with(
+        expect(engine).to receive(:subscribe).with(
           'request.headers',
           'request.uri.raw',
           'request.query',
@@ -60,13 +60,13 @@
           'server.request.method',
         ).and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         expected_waf_arguments = {
           'server.request.cookies' => { 'foo' => 'bar' },
@@ -84,8 +84,8 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
-        result = described_class.publish(operation, request)
+        described_class.subscribe(engine, waf_context)
+        result = described_class.publish(engine, request)
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/contrib/rack/reactive/response_spec.rb b/spec/datadog/appsec/contrib/rack/reactive/response_spec.rb
index 8ea92c75e78..ca51117f5e1 100644
--- a/spec/datadog/appsec/contrib/rack/reactive/response_spec.rb
+++ b/spec/datadog/appsec/contrib/rack/reactive/response_spec.rb
@@ -2,13 +2,13 @@
 
 require 'datadog/appsec/spec_helper'
 require 'datadog/appsec/scope'
-require 'datadog/appsec/reactive/operation'
 require 'datadog/appsec/contrib/rack/gateway/response'
 require 'datadog/appsec/contrib/rack/reactive/response'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/reactive/shared_examples'
 
 RSpec.describe Datadog::AppSec::Contrib::Rack::Reactive::Response do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:processor_context) { instance_double(Datadog::AppSec::Processor::Context) }
   let(:scope) { instance_double(Datadog::AppSec::Scope, processor_context: processor_context) }
   let(:body) { ['Ok'] }
@@ -24,31 +24,31 @@
   end
 
   describe '.publish' do
-    it 'propagates response attributes to the operation' do
-      expect(operation).to receive(:publish).with('response.status', 200)
-      expect(operation).to receive(:publish).with(
+    it 'propagates response attributes to the engine' do
+      expect(engine).to receive(:publish).with('response.status', 200)
+      expect(engine).to receive(:publish).with(
         'response.headers',
         headers,
       )
-      described_class.publish(operation, response)
+      described_class.publish(engine, response)
     end
   end
 
   describe '.subscribe' do
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with(
+        expect(engine).to receive(:subscribe).with(
           'response.status',
           'response.headers',
         ).and_call_original
         expect(processor_context).to_not receive(:run)
-        described_class.subscribe(operation, processor_context)
+        described_class.subscribe(engine, processor_context)
       end
     end
 
     context 'waf arguments' do
       before do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
       end
 
       let(:waf_result) { double(:waf_result, status: :ok, timeout: false) }
@@ -73,8 +73,8 @@
             {},
             Datadog.configuration.appsec.waf_timeout
           ).and_return(waf_result)
-          described_class.subscribe(operation, processor_context)
-          result = described_class.publish(operation, response)
+          described_class.subscribe(engine, processor_context)
+          result = described_class.publish(engine, response)
           expect(result).to be_nil
         end
       end
diff --git a/spec/datadog/appsec/contrib/rails/integration_test_spec.rb b/spec/datadog/appsec/contrib/rails/integration_test_spec.rb
index b564e477c9f..1c1b7eecaad 100644
--- a/spec/datadog/appsec/contrib/rails/integration_test_spec.rb
+++ b/spec/datadog/appsec/contrib/rails/integration_test_spec.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'datadog/tracing/contrib/rails/rails_helper'
 require 'datadog/appsec/contrib/support/integration/shared_examples'
 require 'datadog/appsec/spec_helper'
diff --git a/spec/datadog/appsec/contrib/rails/reactive/action_spec.rb b/spec/datadog/appsec/contrib/rails/reactive/action_spec.rb
index 75c302e2751..fad066ef7cf 100644
--- a/spec/datadog/appsec/contrib/rails/reactive/action_spec.rb
+++ b/spec/datadog/appsec/contrib/rails/reactive/action_spec.rb
@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
 require 'datadog/appsec/contrib/rails/reactive/action'
 require 'datadog/appsec/contrib/rails/gateway/request'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/reactive/shared_examples'
 
 require 'action_dispatch'
 
 RSpec.describe Datadog::AppSec::Contrib::Rails::Reactive::Action do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:request) do
     request_env = Rack::MockRequest.env_for(
       'http://example.com:8080/?a=foo',
@@ -24,11 +26,11 @@
   end
 
   describe '.publish' do
-    it 'propagates request attributes to the operation' do
-      expect(operation).to receive(:publish).with('rails.request.body', { 'foo' => 'bar' })
-      expect(operation).to receive(:publish).with('rails.request.route_params', { id: '1234' })
+    it 'propagates request attributes to the engine' do
+      expect(engine).to receive(:publish).with('rails.request.body', { 'foo' => 'bar' })
+      expect(engine).to receive(:publish).with('rails.request.route_params', { id: '1234' })
 
-      described_class.publish(operation, request)
+      described_class.publish(engine, request)
     end
   end
 
@@ -37,15 +39,15 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with('rails.request.body', 'rails.request.route_params').and_call_original
+        expect(engine).to receive(:subscribe).with('rails.request.body', 'rails.request.route_params').and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         expected_waf_arguments = {
           'server.request.body' => { 'foo' => 'bar' },
@@ -58,8 +60,8 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
-        result = described_class.publish(operation, request)
+        described_class.subscribe(engine, waf_context)
+        result = described_class.publish(engine, request)
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/contrib/sinatra/reactive/routed_spec.rb b/spec/datadog/appsec/contrib/sinatra/reactive/routed_spec.rb
index b30ca74c3f6..690d1609ecb 100644
--- a/spec/datadog/appsec/contrib/sinatra/reactive/routed_spec.rb
+++ b/spec/datadog/appsec/contrib/sinatra/reactive/routed_spec.rb
@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
 require 'datadog/appsec/contrib/sinatra/reactive/routed'
 require 'datadog/appsec/contrib/rack/gateway/request'
 require 'datadog/appsec/contrib/sinatra/gateway/route_params'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/reactive/shared_examples'
 
 require 'rack'
 
 RSpec.describe Datadog::AppSec::Contrib::Sinatra::Reactive::Routed do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:request) do
     Datadog::AppSec::Contrib::Rack::Gateway::Request.new(
       Rack::MockRequest.env_for(
@@ -22,10 +22,10 @@
   let(:routed_params) { Datadog::AppSec::Contrib::Sinatra::Gateway::RouteParams.new({ id: '1234' }) }
 
   describe '.publish' do
-    it 'propagates routed params attributes to the operation' do
-      expect(operation).to receive(:publish).with('sinatra.request.route_params', { id: '1234' })
+    it 'propagates routed params attributes to the engine' do
+      expect(engine).to receive(:publish).with('sinatra.request.route_params', { id: '1234' })
 
-      described_class.publish(operation, [request, routed_params])
+      described_class.publish(engine, [request, routed_params])
     end
   end
 
@@ -34,15 +34,15 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with('sinatra.request.route_params').and_call_original
+        expect(engine).to receive(:subscribe).with('sinatra.request.route_params').and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         expected_waf_arguments = {
           'server.request.path_params' => { id: '1234' }
@@ -54,8 +54,8 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
-        result = described_class.publish(operation, [request, routed_params])
+        described_class.subscribe(engine, waf_context)
+        result = described_class.publish(engine, [request, routed_params])
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/monitor/reactive/set_user_spec.rb b/spec/datadog/appsec/monitor/reactive/set_user_spec.rb
index e29b076ffa0..5e5472f6b2a 100644
--- a/spec/datadog/appsec/monitor/reactive/set_user_spec.rb
+++ b/spec/datadog/appsec/monitor/reactive/set_user_spec.rb
@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 require 'datadog/appsec/spec_helper'
-require 'datadog/appsec/reactive/operation'
+require 'datadog/appsec/reactive/engine'
 require 'datadog/appsec/monitor/reactive/set_user'
 require 'datadog/appsec/reactive/shared_examples'
 
 RSpec.describe Datadog::AppSec::Monitor::Reactive::SetUser do
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
+  let(:engine) { Datadog::AppSec::Reactive::Engine.new }
   let(:user) { double(:user, id: 1) }
 
   describe '.publish' do
-    it 'propagates request body attributes to the operation' do
-      expect(operation).to receive(:publish).with('usr.id', 1)
+    it 'propagates request body attributes to the engine' do
+      expect(engine).to receive(:publish).with('usr.id', 1)
 
-      described_class.publish(operation, user)
+      described_class.publish(engine, user)
     end
   end
 
@@ -22,15 +22,15 @@
 
     context 'not all addresses have been published' do
       it 'does not call the waf context' do
-        expect(operation).to receive(:subscribe).with('usr.id').and_call_original
+        expect(engine).to receive(:subscribe).with('usr.id').and_call_original
         expect(waf_context).to_not receive(:run)
-        described_class.subscribe(operation, waf_context)
+        described_class.subscribe(engine, waf_context)
       end
     end
 
     context 'all addresses have been published' do
       it 'does call the waf context with the right arguments' do
-        expect(operation).to receive(:subscribe).and_call_original
+        expect(engine).to receive(:subscribe).and_call_original
 
         expected_waf_persisted_data = { 'usr.id' => 1 }
 
@@ -40,8 +40,8 @@
           {},
           Datadog.configuration.appsec.waf_timeout
         ).and_return(waf_result)
-        described_class.subscribe(operation, waf_context)
-        result = described_class.publish(operation, user)
+        described_class.subscribe(engine, waf_context)
+        result = described_class.publish(engine, user)
         expect(result).to be_nil
       end
     end
diff --git a/spec/datadog/appsec/reactive/shared_examples.rb b/spec/datadog/appsec/reactive/shared_examples.rb
index 84715c3b95f..352ae336781 100644
--- a/spec/datadog/appsec/reactive/shared_examples.rb
+++ b/spec/datadog/appsec/reactive/shared_examples.rb
@@ -3,98 +3,98 @@
 RSpec.shared_examples 'waf result' do
   context 'is a match' do
     it 'yields result and no blocking action' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :match, timeout: false, actions: [])
       expect(waf_context).to receive(:run).and_return(waf_result)
-      described_class.subscribe(operation, waf_context) do |result|
+      described_class.subscribe(engine, waf_context) do |result|
         expect(result).to eq(waf_result)
       end
-      result = described_class.publish(operation, gateway)
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
 
     it 'yields result and blocking action. The publish method catches the resul as well' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :match, timeout: false, actions: ['block'])
       expect(waf_context).to receive(:run).and_return(waf_result)
-      described_class.subscribe(operation, waf_context) do |result|
+      described_class.subscribe(engine, waf_context) do |result|
         expect(result).to eq(waf_result)
       end
-      block = described_class.publish(operation, gateway)
+      block = described_class.publish(engine, gateway)
       expect(block).to eq(true)
     end
   end
 
   context 'is ok' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :ok, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
 
   context 'is invalid_call' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :invalid_call, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
 
   context 'is invalid_rule' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :invalid_rule, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
 
   context 'is invalid_flow' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :invalid_flow, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
 
   context 'is no_rule' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :no_rule, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
 
   context 'is unknown' do
     it 'does not yield' do
-      expect(operation).to receive(:subscribe).and_call_original
+      expect(engine).to receive(:subscribe).and_call_original
 
       waf_result = double(:waf_result, status: :foo, timeout: false)
       expect(waf_context).to receive(:run).and_return(waf_result)
-      expect { |b| described_class.subscribe(operation, waf_context, &b) }.not_to yield_control
-      result = described_class.publish(operation, gateway)
+      expect { |b| described_class.subscribe(engine, waf_context, &b) }.not_to yield_control
+      result = described_class.publish(engine, gateway)
       expect(result).to be_nil
     end
   end
diff --git a/spec/datadog/tracing/contrib/graphql/support/application.rb b/spec/datadog/tracing/contrib/graphql/support/application.rb
index 88ab68a45fc..ba403ada0d4 100644
--- a/spec/datadog/tracing/contrib/graphql/support/application.rb
+++ b/spec/datadog/tracing/contrib/graphql/support/application.rb
@@ -39,7 +39,6 @@
     TestGraphQL.send(:remove_const, :UserType) if defined?(TestGraphQL::UserType)
     load 'spec/datadog/tracing/contrib/graphql/support/application_schema.rb'
   end
-  let(:operation) { Datadog::AppSec::Reactive::Operation.new('test') }
   let(:schema) { TestGraphQL::Schema }
 end