cased-ruby 0.3.3

data/lib/cased/config.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Cased
+  class Config
+    # The amount of time in seconds to allow the HTTP client to open a
+    # connection.
+    #
+    # @example
+    #    CASED_HTTP_OPEN_TIMEOUT="5" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.http_open_timeout = 5
+    #    end
+    attr_reader :http_open_timeout
+
+    # The amount of time in seconds to allow the HTTP client to read a response
+    # from the server before timing out.
+    #
+    # @example
+    #    CASED_HTTP_READ_TIMEOUT="10" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.http_read_timeout = 10
+    #    end
+    attr_reader :http_read_timeout
+
+    # The Cased HTTP API URL. Defaults to https://api.cased.com
+    #
+    # @example
+    #    CASED_API_URL="https://api.cased.com" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.api_url = "https://api.cased.com"
+    #    end
+    attr_accessor :api_url
+
+    # The URL to publish audit events to. Defaults to https://publish.cased.com
+    #
+    # @example
+    #    CASED_PUBLISH_URL="https://publish.cased.com" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.publish_url = "https://publish.cased.com"
+    #    end
+    attr_accessor :publish_url
+
+    # Publish keys are used to publish to an audit trail.
+    #
+    # A publish key is associated with a single audit trail and is required if
+    # you intend to publish events to Cased in your application.
+    #
+    # @example
+    #    CASED_PUBLISH_KEY="publish_test_5dSfh6xZAuL2Esn3Z2XSM6ReMS21" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.publish_key = "publish_test_5dSfh6xZAuL2Esn3Z2XSM6ReMS21"
+    #    end
+    attr_accessor :publish_key
+
+    #
+    # @example
+    #    CASED_ORGANIZATION_POLICY_KEY="policy_live_1dQpY2mRu3pTCcNGB7a6ewx4WFp" \
+    #    CASED_SECURITY_POLICY_KEY="policy_live_1dQpY9Erf3cKUrooz0BQKmCD4Oc" \
+    #    CASED_USER_POLICY_KEY="policy_live_1dSHQRbtjj17LanuAgpHd3QKtOO" \
+    #      rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.policy_keys = {
+    #        organization: "policy_live_1dQpY2mRu3pTCcNGB7a6ewx4WFp",
+    #        security: "policy_live_1dQpY9Erf3cKUrooz0BQKmCD4Oc",
+    #        user: "policy_live_1dSHQRbtjj17LanuAgpHd3QKtOO",
+    #      }
+    #    end
+    attr_reader :policy_keys
+
+    # Policy keys are used to query for events from audit trails.
+    #
+    # @example
+    #    CASED_POLICY_KEY="policy_live_1dQpY1fUFHzENWhTVMvjCilAKp9" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.raise_on_errors = !Rails.env.production?
+    #    end
+    attr_reader :raise_on_errors
+
+    # Configure whether or not Cased will attempt to publish any events.
+    #
+    # If the CASED_SILENCE environment variable is not nil Cased will
+    # not publish events.
+    #
+    # @example
+    #    CASED_SILENCE="1" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.silence = Rails.env.test?
+    #    end
+    #
+    # @example
+    #   Cased.silence do
+    #     User.create!
+    #   end
+    attr_writer :silence
+
+    def initialize
+      @http_read_timeout = ENV.fetch('CASED_HTTP_READ_TIMEOUT', 10).to_i
+      @http_open_timeout = ENV.fetch('CASED_HTTP_OPEN_TIMEOUT', 5).to_i
+      @raise_on_errors = !ENV['CASED_RAISE_ON_ERRORS'].nil?
+      @api_url = ENV.fetch('CASED_API_URL', 'https://api.cased.com')
+      @publish_url = ENV.fetch('CASED_PUBLISH_URL', 'https://publish.cased.com')
+      @publish_key = ENV['CASED_PUBLISH_KEY']
+      @silence = !ENV['CASED_SILENCE'].nil?
+      @policy_keys = Hash.new do |hash, key|
+        normalized_key = key.to_sym
+        if normalized_key == :default
+          hash[normalized_key] = ENV['CASED_POLICY_KEY']
+        else
+          env_policy_name = key.to_s.tr(' ', '_').tr('-', '_').upcase
+          api_key = ENV["CASED_#{env_policy_name}_POLICY_KEY"]
+
+          hash[normalized_key] = api_key if api_key
+        end
+      end
+    end
+
+    # Policy keys are used to query for events from audit trails.
+    #
+    # @param [Symbol] policy name
+    #
+    # @example
+    #    CASED_POLICY_KEY="policy_live_1dQpY1fUFHzENWhTVMvjCilAKp9" rails server
+    #
+    # @example
+    #    Cased.configure do |config|
+    #      config.policy_key = "policy_live_1dQpY1fUFHzENWhTVMvjCilAKp9"
+    #    end
+    def policy_key(policy = :default)
+      policy_keys[policy.to_sym]
+    end
+
+    def policy_key=(api_key)
+      policy_keys[:default] = api_key
+    end
+
+    def raise_on_errors=(new_val)
+      @raise_on_errors = !!new_val
+    end
+
+    def http_read_timeout=(new_val)
+      @http_read_timeout = new_val.to_i
+    end
+
+    def http_open_timeout=(new_val)
+      @http_open_timeout = new_val.to_i
+    end
+
+    def raise_on_errors?
+      @raise_on_errors
+    end
+
+    def silence?
+      @silence || !ENV['CASED_SILENCE'].nil?
+    end
+  end
+end

data/lib/cased/context.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'cased/context/expander'
+require 'active_support/core_ext/hash/deep_merge'
+
+module Cased
+  class Context
+    def self.current
+      Thread.current[:cased_context] ||= new
+    end
+
+    def self.current=(context)
+      Thread.current[:cased_context] = new(context)
+    end
+
+    def self.clear!
+      Thread.current[:cased_context] = nil
+    end
+
+    attr_reader :context
+
+    def initialize(context = {})
+      @context = Cased::Context::Expander.expand(context || {})
+    end
+
+    def clear
+      @context = {}
+    end
+
+    def merge(new_context = {})
+      if block_given?
+        old_context = @context.dup
+        @context.deep_merge!(Cased::Context::Expander.expand(new_context))
+        yield
+      else
+        @context.deep_merge!(Cased::Context::Expander.expand(new_context))
+      end
+    ensure
+      @context = old_context if block_given?
+    end
+
+    def [](key)
+      @context[key]
+    end
+
+    def []=(key, value)
+      merge(key => value)
+    end
+  end
+end

data/lib/cased/context/expander.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cased
+  class Context
+    class Expander
+      def self.expand(payload)
+        return {} if payload.nil?
+        return payload unless payload.respond_to?(:each)
+
+        cased_payload = payload.dup
+        payload.each do |key, value|
+          if value.respond_to?(:cased_context)
+            cased_payload.delete(key)
+            cased_payload.update(value.cased_context(category: key))
+          elsif value.is_a?(Hash)
+            cased_payload[key] = expand(value)
+          elsif value.is_a?(Array)
+            values = value.collect do |val|
+              if val.respond_to?(:cased_context)
+                val.cased_context
+              else
+                val
+              end
+            end
+            cased_payload.update(key => values)
+          end
+        end
+
+        cased_payload
+      end
+    end
+  end
+end

data/lib/cased/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Cased
+  class Error < StandardError
+    SystemActorMissing = Class.new(self)
+    MissingIdentifier = Class.new(self)
+  end
+end

data/lib/cased/http/client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'cased/http/error'
+require 'faraday'
+require 'faraday_middleware'
+
+module Cased
+  module HTTP
+    class Client
+      def initialize(url:, api_key:)
+        @client = Faraday.new(url: url) do |conn|
+          conn.headers[:user_agent] = "cased-ruby/v#{Cased::VERSION}"
+          conn.headers[:content_type] = 'application/json'
+          conn.headers[:accept] = 'application/json'
+          conn.headers[:authorization] = "Bearer #{api_key}"
+
+          conn.request :json
+          conn.response :json, content_type: /\bjson$/
+
+          conn.options.timeout = Cased.config.http_read_timeout
+          conn.options.open_timeout = Cased.config.http_open_timeout
+
+          conn.adapter :net_http_persistent
+        end
+      end
+
+      # Requests with bodies
+
+      def put(url = nil, body = nil, headers = nil, &block)
+        request(:put, url, body, headers, &block)
+      end
+
+      def post(url = nil, body = nil, headers = nil, &block)
+        request(:post, url, body, headers, &block)
+      end
+
+      def patch(url = nil, body = nil, headers = nil, &block)
+        request(:patch, url, body, headers, &block)
+      end
+
+      # Requests without bodies
+
+      def get(url = nil, params = nil, headers = nil)
+        request(:get, url, nil, headers) do |req|
+          req.params.update(params) if params
+          yield req if block_given?
+        end
+      end
+
+      def head(url = nil, params = nil, headers = nil)
+        request(:head, url, nil, headers) do |req|
+          req.params.update(params) if params
+          yield req if block_given?
+        end
+      end
+
+      def delete(url = nil, params = nil, headers = nil)
+        request(:delete, url, nil, headers) do |req|
+          req.params.update(params) if params
+          yield req if block_given?
+        end
+      end
+
+      def trace(url = nil, params = nil, headers = nil)
+        request(:trace, url, nil, headers) do |req|
+          req.params.update(params) if params
+          yield req if block_given?
+        end
+      end
+
+      private
+
+      def request(method, url = nil, params_or_body = nil, headers = nil, &block)
+        response = @client.send(method, url, params_or_body, headers, &block)
+        return response if response.success?
+
+        # TODO: Look to return a Cased::Response here with error wrapped.
+        klass = Cased::HTTP::Error.class_from_response(response)
+        raise klass.from_response(response)
+      end
+    end
+  end
+end

data/lib/cased/http/error.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'cased/error'
+
+module Cased
+  module HTTP
+    class Error < Cased::Error
+      attr_reader :code
+
+      def initialize(message = '', code = nil)
+        super(message)
+        @code = code
+      end
+
+      def self.from_response(response)
+        new(response.body, response.status)
+      end
+
+      def self.class_from_response(response)
+        klass = ERRORS[response.status]
+
+        if klass
+          klass
+        elsif (300...400).cover?(response.status)
+          RedirectionError
+        elsif (400...500).cover?(response.status)
+          ClientError
+        elsif (500...600).cover?(response.status)
+          ServerError
+        else
+          self
+        end
+      end
+
+      # 3xx
+      RedirectionError = Class.new(self)
+
+      # 4xx
+      ClientError = Class.new(self)
+
+      # 400
+      BadRequest = Class.new(ClientError)
+
+      # 401
+      Unauthorized = Class.new(ClientError)
+
+      # 403
+      Forbidden = Class.new(ClientError)
+
+      # 404
+      NotFound = Class.new(ClientError)
+
+      # 406
+      NotAcceptable = Class.new(ClientError)
+
+      # 408
+      RequestTimeout = Class.new(ClientError)
+
+      # 409
+      Conflict = Class.new(ClientError)
+
+      # 422
+      UnprocessableEntity = Class.new(ClientError)
+
+      # 429
+      TooManyRequests = Class.new(ClientError)
+
+      # 5xx
+      ServerError = Class.new(self)
+
+      # 500
+      InternalServerError = Class.new(ServerError)
+
+      # 502
+      BadGateway = Class.new(ServerError)
+
+      # 503
+      ServiceUnavailable = Class.new(ServerError)
+
+      # 504
+      GatewayTimeout = Class.new(ServerError)
+
+      ERRORS = {
+        400 => BadRequest,
+        401 => Unauthorized,
+        403 => Forbidden,
+        404 => NotFound,
+        406 => NotAcceptable,
+        408 => RequestTimeout,
+        422 => UnprocessableEntity,
+        429 => TooManyRequests,
+        500 => InternalServerError,
+        502 => BadGateway,
+        503 => ServiceUnavailable,
+        504 => GatewayTimeout,
+      }.freeze
+    end
+  end
+end