chronicle-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 01df3cacea5d88d244620c36366cb20ddfd054c6ea59ee4894bb3e1fbd5f25e5
+  data.tar.gz: 5029310077b4c2e31e5da5bbea76881805ad601858586067ccc4dfed50718e9e
+SHA512:
+  metadata.gz: ace523c09d4cd700f40f58656bde01c84ee0f750c21a256c6aa376fb124e9547d1dbd1a41e103d577ed8cab8b32fbffd886203e113e5ffb001a288da6f5e46f1
+  data.tar.gz: a2e3007b8a1d5e6cfc4621acf9b42fd1bee6d1f1efba4bfc3f958ca78aacaeee6102cec904e05ec732e3f4db93d5889c791961b12dffd01ec85a8c92566f2662

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Chronicle
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "chronicle"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install chronicle
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+require 'bundler/gem_tasks'

data/app/controllers/chronicle/api_logs_controller.rb

@@ -0,0 +1,61 @@
+module Chronicle
+  class ApiLogsController < ResourceController
+    FILTER_DEFINITION = {
+      user_id: :exact,
+      request_id: :exact,
+      device_os: :exact,
+      device_id: :exact,
+      device_type: :exact,
+      ip_address: :exact,
+      http_method: :exact,
+      api_endpoint: :like,
+      http_status_code: :exact,
+      brand: :exact,
+      device_model_name: :like,
+      os_version: :exact,
+      backend_version: :exact,
+      client_version: :exact,
+      time_zone: :exact,
+      start_date: :date_range,
+      end_date: :date_range,
+    }.freeze
+
+    def update
+      api_log = ApiLogs::Updater.new(params[:request_id], params.require(:frontend_response_time_ms)).call
+      render json: { status: 'success', id: api_log.id }, status: :ok
+    end
+
+    def kpi_cards
+      render json: ApiLogs::Metrics.kpi_cards(filters: metrics_filters), status: :ok
+    end
+
+    def distribution_metrics
+      render json: ApiLogs::Metrics.distribution_metrics(filters: metrics_filters), status: :ok
+    end
+
+    private
+
+    def model
+      ApiLog
+    end
+
+    def filter_definition
+      FILTER_DEFINITION
+    end
+
+    def date_column
+      :timestamp
+    end
+
+    def eager_load_associations
+      []
+    end
+
+    def metrics_filters
+      params.fetch(:filters, {}).permit(
+        :start_date, :end_date, :client_version, :backend_version,
+        :device_os, :time_zone, :api_endpoint, :http_method
+      )
+    end
+  end
+end

data/app/controllers/chronicle/api_routes_controller.rb

@@ -0,0 +1,35 @@
+module Chronicle
+  class ApiRoutesController < ResourceController
+    FILTER_DEFINITION = {
+      http_method: :exact,
+      path: :like,
+    }.freeze
+
+    before_action :authenticate_admin_user!
+
+    def stats
+      result = ApiRoutes::Stats.new(
+        filters: stats_filters,
+        sort_by: params[:sort_by],
+        sort_direction: params[:sort_direction],
+        page: params[:page],
+        per_page: params[:per_page]
+      ).call
+      render json: result, status: :ok
+    end
+
+    private
+
+    def model
+      ApiRoute
+    end
+
+    def filter_definition
+      FILTER_DEFINITION
+    end
+
+    def stats_filters
+      params.fetch(:filters, {}).permit(:start_date, :end_date, :http_method, :api_endpoint)
+    end
+  end
+end

data/app/controllers/chronicle/application_controller.rb

@@ -0,0 +1,23 @@
+module Chronicle
+  class ApplicationController < ActionController::API
+    rescue_from BaseError do |e|
+      render json: { error: e.message }, status: e.status_code
+    end
+
+    rescue_from ActionController::ParameterMissing do |e|
+      render json: { error: e.message }, status: :bad_request
+    end
+
+    private
+
+    def authenticate_admin_user!
+      auth_token = request.headers['X-Admin-Auth-Token']
+      raise ForbiddenError, 'Missing admin auth token' unless auth_token
+
+      admin_user = AdminUser.find_by(auth_token: auth_token)
+      raise ForbiddenError, 'Invalid admin auth token' unless admin_user
+
+      @current_admin_user = admin_user
+    end
+  end
+end

data/app/controllers/chronicle/auth_controller.rb

@@ -0,0 +1,17 @@
+module Chronicle
+  class AuthController < ApplicationController
+    def login
+      email    = params.require(:email)
+      password = params.require(:password)
+
+      admin_user = AdminUser.find_by(email: email)
+      raise NotFoundError, 'User not found' unless admin_user
+
+      if admin_user.authenticate(password)
+        render json: { admin_user: admin_user.slice(:id, :name, :email, :auth_token) }, status: :ok
+      else
+        render json: { error: 'Invalid email or password' }, status: :unauthorized
+      end
+    end
+  end
+end

data/app/controllers/chronicle/error_groups_controller.rb

@@ -0,0 +1,58 @@
+module Chronicle
+  class ErrorGroupsController < ResourceController
+    before_action :authenticate_admin_user!, only: [:index, :show, :update] # rubocop:disable Rails/LexicallyScopedActionFilter
+    before_action :set_error_group, only: [:update]
+
+    FILTER_DEFINITION = {
+      project: :exact,
+      source_type: :exact,
+      source_name: :like,
+      error_message: :like,
+      status: :exact,
+      fingerprint: :exact,
+      backend_version: :exact,
+      client_version: :exact,
+      start_date: :date_range,
+      end_date: :date_range,
+    }.freeze
+
+    def show
+      record = ErrorGroup.find_by(id: params[:id])
+      raise NotFoundError, 'Error group not found' unless record
+
+      render json: record.get_hash, status: :ok
+    end
+
+    def update
+      if params[:status].present? && ErrorGroup::VALID_STATUSES.exclude?(params[:status])
+        raise BadRequestError, 'Invalid status'
+      end
+
+      @error_group.update!(update_params)
+      render json: @error_group.get_hash, status: :ok
+    end
+
+    private
+
+    def model
+      ErrorGroup
+    end
+
+    def filter_definition
+      FILTER_DEFINITION
+    end
+
+    def date_column
+      :last_seen_at
+    end
+
+    def set_error_group
+      @error_group = ErrorGroup.find_by(id: params[:id])
+      raise NotFoundError, 'Error group not found' unless @error_group
+    end
+
+    def update_params
+      params.permit(:status, :jira_link)
+    end
+  end
+end

data/app/controllers/chronicle/error_logs_controller.rb

@@ -0,0 +1,47 @@
+module Chronicle
+  class ErrorLogsController < ResourceController
+    before_action :authenticate_admin_user!, only: [:index, :show, :destroy] # rubocop:disable Rails/LexicallyScopedActionFilter
+    before_action :set_error_log, only: [:destroy]
+
+    FILTER_DEFINITION = {
+      request_id: :exact,
+      backend_version: :exact,
+      client_version: :exact,
+      user_id: :exact,
+      error_group_id: :exact,
+      start_date: :date_range,
+      end_date: :date_range,
+    }.freeze
+
+    def show
+      record = ErrorLog.find_by(id: params[:id])
+      raise NotFoundError, 'Error log not found' unless record
+
+      render json: record.get_hash, status: :ok
+    end
+
+    def destroy
+      @error_log.destroy
+      render status: :no_content
+    end
+
+    private
+
+    def model
+      ErrorLog
+    end
+
+    def filter_definition
+      FILTER_DEFINITION
+    end
+
+    def set_error_log
+      @error_log = ErrorLog.find_by(id: params[:id])
+      raise NotFoundError, 'Error log not found' unless @error_log
+    end
+
+    def eager_load_associations
+      [:error_group]
+    end
+  end
+end

data/app/controllers/chronicle/resource_controller.rb

@@ -0,0 +1,41 @@
+module Chronicle
+  class ResourceController < ApplicationController
+    include Pagination
+    include Filterable
+
+    before_action :authenticate_admin_user!, only: [:index, :show]
+
+    def index
+      query = build_query(model, filter_definition: filter_definition, filters: params[:filters],
+                                 date_column: date_column)
+      query = query.includes(eager_load_associations) if eager_load_associations.any?
+      render json: paginate(query), status: :ok
+    end
+
+    def show
+      record = model.find_by(id: params[:id])
+      raise NotFoundError, 'Record not found' unless record
+
+      data = record.respond_to?(:get_hash) ? record.get_hash : record.attributes
+      render json: data, status: :ok
+    end
+
+    private
+
+    def model
+      raise NotImplementedError, "#{self.class} must define #model"
+    end
+
+    def filter_definition
+      raise NotImplementedError, "#{self.class} must define #filter_definition"
+    end
+
+    def date_column
+      :created_at
+    end
+
+    def eager_load_associations
+      []
+    end
+  end
+end

data/app/controllers/concerns/chronicle/filterable.rb

@@ -0,0 +1,57 @@
+module Chronicle
+  module Filterable
+    extend ActiveSupport::Concern
+
+    def build_query(model, filter_definition: {}, filters: {}, group_by: nil, date_column: :created_at)
+      scope = model.all
+      params_to_hash = filters.present? ? Util.coerce_to_hash(filters).symbolize_keys : {}
+
+      filter_definition.each do |key, filter_type|
+        param_value = params_to_hash[key]
+        next if param_value.blank?
+
+        scope = apply_filter(scope, key, filter_type, param_value, date_column)
+      end
+
+      scope = scope.group(group_by) if group_by.present?
+
+      scope
+    end
+
+    private
+
+    def apply_filter(scope, key, filter_type, value, date_column)
+      case filter_type
+      when :like
+        sanitized_value = "%#{ActiveRecord::Base.sanitize_sql_like(value)}%"
+        scope.where(scope.arel_table[key].matches(sanitized_value))
+      when :date_range
+        apply_date_range_filter(scope, key, value, date_column)
+      when :exact
+        scope.where(key => value)
+      end
+    end
+
+    def apply_date_range_filter(scope, key, value, date_column)
+      date = Util.parse_date(value)
+      raise BadRequestError, 'Invalid Date Format' if date.nil?
+
+      case key
+      when :start_date
+        apply_date_range(scope, { from: date.beginning_of_day }, date_key: date_column)
+      when :end_date
+        apply_date_range(scope, { to: date.end_of_day }, date_key: date_column)
+      else
+        scope.where(date_column => date.all_day)
+      end
+    end
+
+    def apply_date_range(scope, range, date_key: :datetime)
+      return scope if range.nil?
+
+      scope = scope.where(date_key => (range[:from])..) if range[:from].present?
+      scope = scope.where(date_key => ..(range[:to]))   if range[:to].present?
+      scope
+    end
+  end
+end

data/app/controllers/concerns/chronicle/pagination.rb

@@ -0,0 +1,41 @@
+module Chronicle
+  module Pagination
+    extend ActiveSupport::Concern
+
+    DEFAULT_LIMIT = 20
+    MAX_LIMIT = 100
+
+    def paginate(scope)
+      limit = validate_limit
+      last_id = params[:last_id]&.to_i
+
+      scope = scope.where(id: ...last_id) if last_id.present?
+      scope = scope.order(id: order_key).limit(limit)
+      batch_count = scope.size
+
+      {
+        data: scope.map { |record| item_data(record) },
+        pagination: {
+          has_more: batch_count == limit,
+          last_id: scope.last&.id,
+          batch_count: batch_count,
+        },
+      }
+    end
+
+    private
+
+    def validate_limit
+      limit = params[:limit].present? ? [params[:limit].to_i, 1].max : DEFAULT_LIMIT
+      [limit, MAX_LIMIT].min
+    end
+
+    def order_key
+      params[:order_by] == 'asc' ? :asc : :desc
+    end
+
+    def item_data(record)
+      record.respond_to?(:get_hash) ? record.get_hash : record.attributes
+    end
+  end
+end

data/app/errors/chronicle/authentication_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class AuthenticationError < BaseError
+    def initialize(message = 'Request not acceptable')
+      super(message, 401)
+    end
+  end
+end

data/app/errors/chronicle/bad_request_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class BadRequestError < BaseError
+    def initialize(message = 'Bad Request')
+      super(message, 400)
+    end
+  end
+end

data/app/errors/chronicle/base_error.rb

@@ -0,0 +1,10 @@
+module Chronicle
+  class BaseError < StandardError
+    attr_reader :status_code
+
+    def initialize(message = nil, status_code = 400)
+      super(message)
+      @status_code = status_code
+    end
+  end
+end

data/app/errors/chronicle/forbidden_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class ForbiddenError < BaseError
+    def initialize(message = 'Unauthorized')
+      super(message, 403)
+    end
+  end
+end

data/app/errors/chronicle/not_acceptable_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class NotAcceptableError < BaseError
+    def initialize(message = 'Request not acceptable')
+      super(message, 406)
+    end
+  end
+end

data/app/errors/chronicle/not_found_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class NotFoundError < BaseError
+    def initialize(message = 'Resource not found')
+      super(message, 404)
+    end
+  end
+end

data/app/errors/chronicle/resource_busy_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class ResourceBusyError < BaseError
+    def initialize(message = 'Resource busy')
+      super(message, 409)
+    end
+  end
+end

data/app/errors/chronicle/validation_error.rb

@@ -0,0 +1,7 @@
+module Chronicle
+  class ValidationError < BaseError
+    def initialize(message = 'Validation failed')
+      super(message, 422)
+    end
+  end
+end

data/app/jobs/chronicle/application_job.rb

@@ -0,0 +1,4 @@
+module Chronicle
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/chronicle/flush_api_logs_job.rb

@@ -0,0 +1,9 @@
+module Chronicle
+  class FlushApiLogsJob < ApplicationJob
+    queue_as :low
+
+    def perform
+      Chronicle.flush_api_logs!
+    end
+  end
+end

data/app/mailers/chronicle/application_mailer.rb

@@ -0,0 +1,6 @@
+module Chronicle
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/chronicle/admin_user.rb

@@ -0,0 +1,16 @@
+module Chronicle
+  class AdminUser < ApplicationRecord
+    enum :role, a1: 0, a2: 1
+    validates :password, presence: true, length: { minimum: 6 }
+    validates :email, :auth_token, :name, presence: true
+
+    has_secure_password validations: false
+
+    A1 = :a1
+    A2 = :a2
+
+    def basic_info
+      self.slice(:id, :name, :email)
+    end
+  end
+end

data/app/models/chronicle/api_log.rb

@@ -0,0 +1,25 @@
+module Chronicle
+  class ApiLog < ApplicationRecord
+    after_commit :sync_api_route, on: :create
+
+    def get_hash
+      hash = attributes
+
+      klass = Chronicle.config.user_model
+
+      hash['user'] = klass.find_by(id: user_id)&.basic_info if user_id.present? && klass.present?
+
+      hash
+    end
+
+    private
+
+    def sync_api_route
+      return if api_endpoint.blank? || http_method.blank?
+      return if ApiRoute.exists?(path: api_endpoint, http_method: http_method)
+
+      ApiRoute.create!(path: api_endpoint, http_method: http_method, first_seen_at: created_at,
+                       created_at: created_at, updated_at: created_at)
+    end
+  end
+end

data/app/models/chronicle/api_route.rb

@@ -0,0 +1,5 @@
+module Chronicle
+  class ApiRoute < ApplicationRecord
+    validates :path, :http_method, presence: true
+  end
+end

data/app/models/chronicle/application_record.rb

@@ -0,0 +1,5 @@
+module Chronicle
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/chronicle/error_group.rb

@@ -0,0 +1,53 @@
+module Chronicle
+  class ErrorGroup < ApplicationRecord
+    has_many :error_logs, dependent: :destroy
+
+    OPEN = 'open'.freeze
+    RESOLVED = 'resolved'.freeze
+    IGNORED = 'ignored'.freeze
+    VALID_STATUSES = [OPEN, RESOLVED, IGNORED].freeze
+
+    validates :project, presence: true
+    validates :fingerprint, presence: true
+    validates :source_type,
+              :source_name,
+              :error_message,   presence: true
+    validates :status,          inclusion: { in: VALID_STATUSES }, presence: true
+    validates :first_seen_at,
+              :last_seen_at,    presence: true
+    validates :occurrence_count, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+    # Derives a deterministic fingerprint from the structural identity of an error.
+    # Same source location + message + cleaned backtrace always yields the same hash,
+    # so two occurrences of the same bug map to the same group.
+    def self.compute_fingerprint(error_log)
+      payload = [
+        error_log.source_type,
+        error_log.source_name,
+        error_log.error_message,
+        error_log.cleaned_backtrace.to_s.first(2000),
+      ].join("\xff")
+      Digest::SHA256.hexdigest(payload)
+    end
+
+    # Atomically records a new occurrence of this error.
+    # Uses a row-level lock so concurrent increments never collide.
+    def record_occurrence!(backend_version: nil, client_version: nil, at: Time.current)
+      with_lock do
+        self.last_seen_at      = [last_seen_at, at].compact.max
+        self.backend_version   = backend_version if backend_version.present?
+        self.client_version    = client_version  if client_version.present?
+        self.occurrence_count += 1
+        save!
+      end
+    end
+
+    def get_hash
+      attributes.symbolize_keys.merge(error_fingerprint: fingerprint)
+    end
+
+    def as_json(_options = {})
+      get_hash
+    end
+  end
+end