tcell_agent 0.2.21 → 0.2.22

data/spec/lib/tcell_agent/rails/middleware/appsensor_middleware_spec.rb

@@ -41,6 +41,11 @@ module TCellAgent
           subject { withTCellMiddleware( app ) }
 
           context "Appsensor Middleware" do
+            before(:all) do
+              # need to ensure default rules file is loaded
+              AppSensorRuleManager.instance.load_default_rules_file
+            end
+
             before(:each) do
               TCellAgent.configuration = TCellAgent::Configuration.new
               TCellAgent.configuration.read_config_from_file(get_test_resource_path("normal_config.json"))

data/spec/lib/tcell_agent/rails/middleware/dlp_middleware_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'rack/test'
 require 'rack'
 
+require 'tcell_agent/rails/dlp/process_request'
+
 module TCellAgent
   module Instrumentation
     module Rails
@@ -58,7 +60,7 @@ module TCellAgent
                   tcell_context.add_response_db_filter("secretvalue", action_obj, "databx", "*", "tablex", "columnb")
                 end
               end
-              TCellAgent::AroundFilters.handle_request_dlp_parameters(rack_request)
+              TCellAgent::DLP.handle_request_dlp_parameters(rack_request)
               #if tcell_context && dlp_policy && dlp_policy.has_actions_for_form_parameter?
               #  for_params(rack_request) { |method, param_name, param_value|
               #    actions = dlp_policy.get_actions_for_form_parameter(param_name, tcell_context.route_id)
@@ -167,4 +169,4 @@ module TCellAgent
       end
     end
   end
-end
+end

data/spec/lib/tcell_agent/rails/routes/grape_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+module TCellAgent
+  module Instrumentation
+
+    # Fake out grape gem
+    module Grape
+      class API
+      end
+    end
+
+    class GrapeRoute < Grape::API
+    end
+
+    class RegularRoute
+    end
+
+    describe ".grape_route?" do
+      context "rails 3" do
+        context "with a regular route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 3)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: RegularRoute.new)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+
+        context "with a grape route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 3)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: GrapeRoute)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+      end
+
+      context "rails 4.0" do
+        context "with a regular route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: RegularRoute.new)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+
+        context "with a grape route" do
+          it "should return true" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: GrapeRoute)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(true)
+          end
+        end
+      end
+
+      context "rails 4.1" do
+        context "with a regular route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 1)
+
+            route = double("route", app: RegularRoute.new)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+
+        context "with a grape route" do
+          it "should return true" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 1)
+
+            route = double("route", app: GrapeRoute)
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(true)
+          end
+        end
+      end
+
+      context "rails 4.2" do
+        context "with a regular route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 2)
+
+            route = double("route", app: double("app", app: RegularRoute.new))
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+
+        context "with a grape route" do
+          it "should return true" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 2)
+
+            route = double("route", app: double("app", app: GrapeRoute))
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(true)
+          end
+        end
+      end
+
+      context "rails 5.0" do
+        context "with a regular route" do
+          it "should return false" do
+            stub_const("::Rails::VERSION::MAJOR", 5)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: double("app", app: RegularRoute.new))
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(false)
+          end
+        end
+
+        context "with a grape route" do
+          it "should return true" do
+            stub_const("::Rails::VERSION::MAJOR", 5)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            route = double("route", app: double("app", app: GrapeRoute))
+
+            is_grape_route = TCellAgent::Instrumentation.grape_route?(route)
+
+            expect(is_grape_route).to eq(true)
+          end
+        end
+      end
+    end
+
+    describe ".grape_route_info" do
+
+      context "with grape version 0.10.1" do
+        it "should use route_method and route_path" do
+          route = double("route")
+          grape_gem = double("grape_gem", version: "0.10.1")
+
+          expect(Gem).to receive(:loaded_specs).and_return({
+            "grape" => grape_gem
+          })
+          expect(route).to receive(:route_method).and_return("POST")
+          expect(route).to receive(:route_path).and_return("/grape_api/endpoint")
+
+          route_info = TCellAgent::Instrumentation.grape_route_info(route)
+
+          expect(route_info[:method]).to eq("POST")
+          expect(route_info[:path]).to eq("/grape_api/endpoint")
+        end
+      end
+
+      context "with grape version 0.16.0" do
+        it "should use request_method and path" do
+          route = double("route")
+          grape_gem = double("grape_gem", version: "0.16.0")
+
+          expect(Gem).to receive(:loaded_specs).and_return({
+            "grape" => grape_gem
+          })
+          expect(route).to receive(:request_method).and_return("POST")
+          expect(route).to receive(:path).and_return("/grape_api/endpoint")
+
+          route_info = TCellAgent::Instrumentation.grape_route_info(route)
+
+          expect(route_info[:method]).to eq("POST")
+          expect(route_info[:path]).to eq("/grape_api/endpoint")
+        end
+      end
+
+    end
+
+    describe ".instrument_grape_api" do
+
+      context "with nil routes" do
+        it "should not send any events" do
+          expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+          TCellAgent::Instrumentation.instrument_grape_api("/api", nil)
+        end
+      end
+
+      context "with empty routes" do
+        it "should not send any events" do
+          expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+          TCellAgent::Instrumentation.instrument_grape_api("/api", [])
+        end
+      end
+
+      context "with grape version < 1.16" do
+        before(:each) do
+          grape_gem = double("grape_gem", version: "0.10.1")
+
+          expect(Gem).to receive(:loaded_specs).and_return({
+            "grape" => grape_gem
+          }).at_least(1)
+        end
+
+        context "with one route" do
+          it "should send one event" do
+            route = double("grape_route", route_method: "GET", route_path: "/users")
+
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "GET", "409553642", nil, nil
+            ).and_call_original
+
+            TCellAgent::Instrumentation.instrument_grape_api("/api", [route])
+          end
+        end
+
+        context "with two routes" do
+          it "should send two events" do
+            route = double("grape_route", route_method: "GET", route_path: "/users")
+            route_dos = double("grape_route", route_method: "POST", route_path: "/users")
+
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "GET", "409553642", nil, nil
+            ).and_call_original
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "POST", "-2105512096", nil, nil
+            ).and_call_original
+
+            TCellAgent::Instrumentation.instrument_grape_api("/api", [route, route_dos])
+          end
+        end
+      end
+
+      context "with grape version >= 1.16" do
+        before(:each) do
+          grape_gem = double("grape_gem", version: "0.16.0")
+
+          expect(Gem).to receive(:loaded_specs).and_return({
+            "grape" => grape_gem
+          }).at_least(1)
+        end
+
+        context "with one route" do
+          it "should send one event" do
+            route = double("grape_route", request_method: "GET", path: "/users")
+
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "GET", "409553642", nil, nil
+            ).and_call_original
+
+            TCellAgent::Instrumentation.instrument_grape_api("/api", [route])
+          end
+        end
+
+        context "with two routes" do
+          it "should send two events" do
+            route = double("grape_route", request_method: "GET", path: "/users")
+            route_dos = double("grape_route", request_method: "POST", path: "/users")
+
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "GET", "409553642", nil, nil
+            ).and_call_original
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/api/users", "POST", "-2105512096", nil, nil
+            ).and_call_original
+
+            TCellAgent::Instrumentation.instrument_grape_api("/api", [route, route_dos])
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/tcell_agent/rails/routes/route_id_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module TCellAgent
+  module Instrumentation
+
+    describe RouteId do
+      TCELL_CONTEXT_KEY = TCellAgent::Instrumentation::TCELL_ID
+
+      describe ".update_context" do
+
+        context "with nil route" do
+          it "should not set anything" do
+            tcell_context = TCellData.new
+            tcell_context.route_id = nil
+
+            RouteId.update_context({TCELL_CONTEXT_KEY => tcell_context}, {}, nil)
+
+            expect(tcell_context.route_id).to eq(nil)
+            expect(tcell_context.grape_mount_endpoint).to eq(nil)
+            expect(tcell_context.path_parameters).to eq(nil)
+          end
+        end
+
+        context "with nil context" do
+          it "should not set anything "do
+            route = double("route")
+            expect(route).to_not receive(:path)
+
+            RouteId.update_context({}, {}, route)
+          end
+        end
+
+        context "with a regular route and parameters" do
+          it "should set the route id" do
+            tcell_context = TCellData.new
+            tcell_context.route_id = nil
+            tcell_context.request_method = "GET"
+
+            route = double(
+              "route",
+              path: double("path", spec: "/some/regular/path"))
+
+            expect(TCellAgent::Instrumentation).to receive(:grape_route?).with(route).and_return(false)
+
+            RouteId.update_context({TCELL_CONTEXT_KEY => tcell_context}, {id: 1}, route)
+
+            expect(tcell_context.route_id).to eq(
+              TCellAgent::SensorEvents::Util.calculateRouteId("GET", "/some/regular/path")
+            )
+            expect(tcell_context.grape_mount_endpoint).to eq(nil)
+            expect(tcell_context.path_parameters).to eq({id: 1})
+          end
+        end
+
+        context "with a grape route and parameters" do
+          it "should set the grape mount endpoint" do
+            tcell_context = TCellData.new
+            tcell_context.route_id = nil
+            tcell_context.request_method = "GET"
+
+            route = double(
+              "route",
+              path: double("path", spec: "/grape_api"))
+
+            expect(TCellAgent::Instrumentation).to receive(:grape_route?).with(route).and_return(true)
+
+            RouteId.update_context({TCELL_CONTEXT_KEY => tcell_context}, {id: 1}, route)
+
+            expect(tcell_context.route_id).to eq(nil)
+            expect(tcell_context.grape_mount_endpoint).to eq("/grape_api")
+            expect(tcell_context.path_parameters).to eq({id: 1})
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/tcell_agent/rails/routes/routes_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+module TCellAgent
+  module Instrumentation
+
+    # Fake out grape gem
+    module Grape
+      class API
+      end
+    end
+
+    class GrapeRoute < Grape::API
+
+      def self.routes
+        ["/api/grape/route"]
+      end
+
+    end
+
+    describe ".instrument_route" do
+      context "with a nil route" do
+        it "shouldn't be reported" do
+          configuration = double("configuration", enabled: true, should_instrument?: true)
+
+          expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+          expect(TCellAgent::Instrumentation).to_not receive(:instrument_grape_api)
+          expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+
+          Rails.instrument_route(nil)
+        end
+      end
+
+      context "with rails 5.0" do
+        context "with a regular route" do
+          it "should report it" do
+            stub_const("::Rails::VERSION::MAJOR", 5)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/regular/route"),
+              defaults: {},
+              app: double("app", app: "some_app"))
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(route).to receive(:verb).and_return("GET|POST").twice()
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/regular/route", "GET", "-1187510355", nil, "{}"
+            ).and_call_original
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/regular/route", "POST", "1100742947", nil, "{}"
+            ).and_call_original
+
+            Rails.instrument_route(route)
+          end
+        end
+
+        context "with a grape route" do
+          it "should instrument the grape endpoint" do
+            stub_const("::Rails::VERSION::MAJOR", 5)
+            stub_const("::Rails::VERSION::MINOR", 0)
+
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/grape"),
+              defaults: {},
+              app: double("app", app: GrapeRoute))
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(route).to receive(:verb).and_return("GET|POST")
+            expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+            expect(TCellAgent::Instrumentation).to receive(:instrument_grape_api).with(
+              "/grape", ["/api/grape/route"]
+            )
+
+            Rails.instrument_route(route)
+          end
+        end
+      end
+
+      context "with rails 4.2" do
+        context "with a regular route" do
+          it "should report it" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 2)
+
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/regular/route"),
+              defaults: {},
+              constraints: {request_method: "DELETE"},
+              app: double("app", app: "some_app"))
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(TCellAgent::Instrumentation).to_not receive(:instrument_grape_api)
+            expect(route).to receive(:verb).and_return(/DELETE/).at_least(9)
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/regular/route", "DELETE", "-990446408", nil, "{}"
+            ).and_call_original
+
+            Rails.instrument_route(route)
+          end
+        end
+
+        context "with a grape route" do
+          it "should instrument the grape endpoint" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 2)
+
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/grape"),
+              defaults: {},
+              constraints: {request_method: "PUT"},
+              app: double("app", app: GrapeRoute))
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(TCellAgent::Instrumentation).to receive(:instrument_grape_api).with(
+              "/grape", ["/api/grape/route"]
+            )
+            expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+
+            Rails.instrument_route(route)
+          end
+        end
+      end
+
+      context "with rails 4.1" do
+        context "with a regular route" do
+          it "should report it" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 1)
+
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/regular/route"),
+              defaults: {},
+              constraints: {request_method: "PUT"},
+              app: "some_app")
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(TCellAgent::Instrumentation).to_not receive(:instrument_grape_api)
+            expect(route).to receive(:verb).and_return(/PUT/).at_least(9)
+            expect(TCellAgent::SensorEvents::AppRoutesSensorEvent).to receive(:new).with(
+              "/regular/route", "PUT", "-1393108268", nil, "{}"
+            ).and_call_original
+
+            Rails.instrument_route(route)
+          end
+        end
+
+        context "with a grape route" do
+          it "should instrument the grape endpoint" do
+            stub_const("::Rails::VERSION::MAJOR", 4)
+            stub_const("::Rails::VERSION::MINOR", 1)
+            configuration = double("configuration", enabled: true, should_instrument?: true)
+            route = double(
+              "route",
+              path: double("path", spec: "/grape"),
+              defaults: {},
+              constraints: {request_method: "PUT"},
+              app: GrapeRoute)
+
+            expect(TCellAgent).to receive(:configuration).and_return(configuration).twice()
+            expect(TCellAgent::Instrumentation).to receive(:instrument_grape_api).with(
+              "/grape", ["/api/grape/route"]
+            )
+            expect(TCellAgent::SensorEvents::Util).to_not receive(:calculateRouteId)
+
+            Rails.instrument_route(route)
+          end
+        end
+      end
+    end
+
+  end
+end