cased-ruby 0.3.3

data/lib/cased/instrumentation/controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative './log_subscriber'
+
+module Cased
+  module Instrumentation
+    module Controller
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages = super
+          count = payload[:cased_events]
+          if count
+            messages << format('Cased: %<count>d %<suffix>s', count: count, suffix: 'event'.pluralize(count))
+          end
+          messages
+        end
+      end
+
+      protected
+
+      def process_action(action, *args)
+        Cased::Instrumentation::LogSubscriber.reset_events
+        super
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:cased_events] = Cased::Instrumentation::LogSubscriber.events
+      end
+    end
+  end
+end

data/lib/cased/instrumentation/log_subscriber.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module Cased
+  module Instrumentation
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.events=(value)
+        Thread.current['cased_events'] = value
+      end
+
+      def self.events
+        Thread.current['cased_events'] ||= 0
+      end
+
+      def self.reset_events
+        self.events = 0
+      end
+
+      def audit_event(event)
+        self.class.events += 1
+
+        event = JSON.generate(event.payload[:event])
+        name = color('Cased', CYAN, true)
+        debug "  #{name} #{event}"
+      end
+
+      attach_to :cased
+    end
+  end
+end

data/lib/cased/integrations/sidekiq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'cased/integrations/sidekiq/client_middleware'
+require 'cased/integrations/sidekiq/server_middleware'
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Cased::Integrations::Sidekiq::ClientMiddleware
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Cased::Integrations::Sidekiq::ServerMiddleware
+  end
+end

data/lib/cased/integrations/sidekiq/client_middleware.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cased
+  module Integrations
+    module Sidekiq
+      class ClientMiddleware
+        def call(_worker_class, job, _queue, _redis_pool)
+          job['cased_context'] = Cased.context.context
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/cased/integrations/sidekiq/server_middleware.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cased
+  module Integrations
+    module Sidekiq
+      class ServerMiddleware
+        def call(_worker, job, _queue)
+          context = (job['cased_context'] || {})
+          context['job_class'] = job['class']
+
+          Cased::Context.current = context
+
+          yield
+        ensure
+          Cased::Context.clear!
+        end
+      end
+    end
+  end
+end

data/lib/cased/model.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/deep_merge'
+require 'cased/context'
+
+module Cased
+  module Model
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Establishes a default `cased_category` that matches nicely to
+      # the class name. The default instance level `cased_category` uses this.
+      #
+      # @return [Symbol]
+      def cased_category
+        @cased_category ||= begin
+          category = ActiveSupport::Inflector.underscore(name)
+          category.to_sym
+        end
+      end
+    end
+
+    # Instruments events for the model. These events are sent directly to Cased.
+    #
+    # @param action [String, Symbol] suffix of the action.
+    # @param category [String, Symbol] action category name.
+    # @param payload [Hash] additional payload information about the event.
+    #
+    # @return [Array] of responses from Cased.publishers
+    def cased(action, category: cased_category, payload: {})
+      body = cased_payload.deep_merge(payload)
+
+      Cased.publish(body.merge(action: "#{category}.#{action}"))
+    end
+
+    # Defines the event key prefix for all model events.
+    #
+    # Defaults to :my_model if the class this thing is included in is MyModel.
+    # Feel free to override to provide a more semantic, meaningful name
+    # if you so desire.
+    #
+    # @return [String]
+    def cased_category
+      self.class.cased_category
+    end
+
+    # Defines the default payload for every event.
+    #
+    # @return [Hash]
+    def cased_payload
+      {
+        cased_category => self,
+      }
+    end
+
+    # Defines the Cased identifier for the current instance.
+    #
+    # @example
+    #   user.cased_id # => User;1
+    #
+    # @example
+    #   client.cased_id # => Client;1
+    #
+    # @raise [Cased::Error::MissingIdentifier] description
+    # @return [String]
+    def cased_id; end
+
+    # Internal: The String representation within the Cased object.
+    #
+    # @return [String] if cased_category key is present in cased_context.
+    def cased_human
+      cased_context[cased_category]
+    end
+
+    # Internal: Defines the payload to describe the current subject.
+    # Can be overridden in model to change fields returned.
+    #
+    # @param [String, Symbol] category prefix that can be set to override Hash prefix.
+    #
+    # @example
+    #   model.cased_context # => { user_id: "User;1", user: "flynn" }
+    #   model.cased_context(category: :actor) # => { actor_id: "User;1", actor: "flynn" }
+    #
+    # @return [Hash]
+    def cased_context(category: cased_category)
+      context = {}
+      context["#{category}_id".to_sym] = cased_id if cased_id
+
+      if method(:to_s).owner == self.class
+        context[category] = Cased::Sensitive::String.new(to_s, label: self.class.name)
+      end
+
+      context
+    end
+  end
+end

data/lib/cased/policy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'cased/query'
+
+module Cased
+  class Policy
+    attr_reader :api_key
+    attr_reader :client
+
+    def initialize(api_key:)
+      @api_key = api_key
+      @client = Cased::Clients.create(api_key: @api_key)
+    end
+
+    def events(phrase: nil, variables: {})
+      Query.new(@client, phrase: phrase, variables: variables)
+    end
+
+    def event(id)
+      response = @client.get("events/#{id}")
+      response.body
+    end
+  end
+end

data/lib/cased/publishers.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'cased/publishers/active_support_publisher'
+require 'cased/publishers/http_publisher'
+require 'cased/publishers/null_publisher'
+require 'cased/publishers/test_publisher'

data/lib/cased/publishers/active_support_publisher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# ActiveSupport::Notifications will fail if concurrent isn't loaded
+require 'concurrent'
+require 'active_support/notifications'
+require 'cased/publishers/base'
+
+module Cased
+  module Publishers
+    class ActiveSupportPublisher < Base
+      def publish(event)
+        ::ActiveSupport::Notifications.instrument('event.cased', event: event)
+      end
+    end
+  end
+end

data/lib/cased/publishers/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'cased/publishers/error'
+
+module Cased
+  module Publishers
+    class Base
+      def publish(_audit_event)
+        raise "#{self.class} must implement the #{self.class}#publish method"
+      end
+
+      def ==(other)
+        self.class == other.class
+      end
+    end
+  end
+end

data/lib/cased/publishers/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'cased/error'
+
+module Cased
+  module Publishers
+    # Public: Standard exception class all Cased publisher errors inherit from.
+    class Error < Cased::Error
+    end
+  end
+end

data/lib/cased/publishers/http_publisher.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'cased/publishers/base'
+
+module Cased
+  module Publishers
+    class HTTPPublisher < Base
+      def publish(audit_event)
+        Cased.clients.publish.post do |req|
+          req.body = JSON.generate(audit_event)
+        end
+      end
+    end
+  end
+end

data/lib/cased/publishers/null_publisher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'cased/publishers/base'
+
+module Cased
+  module Publishers
+    class NullPublisher < Base
+      def publish(_event); end
+    end
+  end
+end

data/lib/cased/publishers/test_publisher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'cased/publishers/base'
+
+module Cased
+  module Publishers
+    class TestPublisher < Base
+      attr_reader :events
+
+      def initialize
+        @events = []
+      end
+
+      def publish(event)
+        @events << event
+      end
+    end
+  end
+end

data/lib/cased/query.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'cased/collection_response'
+
+module Cased
+  class Query
+    # @param client [Cased::HTTP::Client] the HTTP client authorized to query an
+    #   audit trail policy
+    # @param phrase [String, nil] the phrase to search for audit trail events
+    # @param variables [Hash] the query variables
+    def initialize(client, phrase: nil, variables: {})
+      raise ArgumentError, 'variables must be a Hash' unless variables.is_a?(Hash)
+
+      @client = client
+      @phrase = phrase
+      @page = 1
+      @limit = 25
+      @variables = variables
+    end
+
+    # @param new_phrase [String] The audit trail policy search phrase.
+    # @return [Cased::Query]
+    def phrase(new_phrase)
+      @phrase = new_phrase
+
+      self
+    end
+
+    # @param new_limit [Integer] The number of audit trail events to return.
+    # @return [Cased::Query]
+    def limit(new_limit)
+      @limit = [[new_limit, 100].min, 1].max
+
+      self
+    end
+
+    # @param new_page [Integer] The page of audit trail events to request.
+    # @return [Cased::Query]
+    def page(new_page)
+      @page = [1, new_page.to_i].max
+
+      self
+    end
+
+    # If any of these methods are called we need the request to fulfil the response.
+    delegate :results, \
+      :total_count, \
+      :total_pages, \
+      :next_page_url?, \
+      :next_page_url, \
+      :next_page, \
+      :next_page?, \
+      :previous_page_url?, \
+      :previous_page_url, \
+      :previous_page, \
+      :previous_page?, \
+      :first_page_url?, \
+      :first_page_url, \
+      :first_page, \
+      :first_page?, \
+      :last_page_url?, \
+      :last_page_url, \
+      :last_page, \
+      :last_page?, \
+      :error, \
+      :error?, \
+      :success?, \
+      to: :response
+
+    def response
+      return @response if defined?(@response)
+
+      @response = begin
+        resp = @client.get('events') do |req|
+          req.params['phrase'] = @phrase unless @phrase.nil?
+          req.params['per_page'] = @limit unless @limit.nil?
+          req.params['page'] = @page unless @page.nil?
+          req.params['variables'] = @variables unless @variables.nil?
+        end
+
+        CollectionResponse.new(response: resp)
+      rescue Cased::HTTP::Error, Faraday::Error => e
+        CollectionResponse.new(exception: e)
+      end
+    end
+  end
+end

data/lib/cased/rack_middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Cased
+  class RackMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Cased::Context.clear!
+    end
+  end
+end