Chore: Remove redis backed reporting (#669)

app/builders/report_builder.rb

@@ -1,77 +0,0 @@
-class ReportBuilder
-  include CustomExceptions::Report
-
-  # Usage
-  #  rb = ReportBuilder.new a, { metric: 'conversations_count', type: :account, id: 1}
-  #  rb = ReportBuilder.new a, { metric: 'avg_first_response_time', type: :agent, id: 1}
-
-  IDENTITY_MAPPING = {
-    account: AccountIdentity,
-    agent: AgentIdentity
-  }.freeze
-
-  def initialize(account, params)
-    @account = account
-    @params = params
-    @identity = get_identity
-    @start_time, @end_time = validate_times
-  end
-
-  def build
-    metric = @identity.send(@params[:metric])
-    if metric.get.nil?
-      metric.delete
-      result = {}
-    else
-      result = metric.get_padded_range(@start_time, @end_time) || {}
-    end
-    formatted_hash(result)
-  end
-
-  private
-
-  def get_identity
-    identity_class = IDENTITY_MAPPING[@params[:type]]
-    raise InvalidIdentity if identity_class.nil?
-
-    @params[:id] = @account.id if identity_class == AccountIdentity
-    identity_id = @params[:id]
-    raise IdentityNotFound if identity_id.nil?
-
-    tags = identity_class == AccountIdentity ? nil : { account_id: @account.id }
-    identity = identity_class.new(identity_id, tags: tags)
-    raise MetricNotFound if @params[:metric].blank?
-    raise MetricNotFound unless identity.respond_to?(@params[:metric])
-
-    identity
-  end
-
-  def validate_times
-    start_time = @params[:since] || Time.now.end_of_day - 30.days
-    end_time = @params[:until] || Time.now.end_of_day
-    start_time = begin
-                   parse_date_time(start_time)
-                 rescue StandardError
-                   raise(InvalidStartTime)
-                 end
-    end_time = begin
-                 parse_date_time(end_time)
-               rescue StandardError
-                 raise(InvalidEndTime)
-               end
-    [start_time, end_time]
-  end
-
-  def parse_date_time(datetime)
-    return datetime if datetime.is_a?(DateTime)
-    return datetime.to_datetime if datetime.is_a?(Time) || datetime.is_a?(Date)
-
-    DateTime.strptime(datetime, '%s')
-  end
-
-  def formatted_hash(hash)
-    hash.each_with_object([]) do |p, arr|
-      arr << { value: p[1], timestamp: p[0] }
-    end
-  end
-end

app/controllers/api/v1/accounts/reports_controller.rb

@@ -1,99 +0,0 @@
-class Api::V1::Accounts::ReportsController < Api::BaseController
-  include CustomExceptions::Report
-  include Constants::Report
-
-  around_action :report_exception
-
-  def account
-    builder = ReportBuilder.new(current_account, account_report_params)
-    data = builder.build
-    render json: data
-  end
-
-  def agent
-    builder = ReportBuilder.new(current_account, agent_report_params)
-    data = builder.build
-    render json: data
-  end
-
-  def account_summary
-    render json: account_summary_metrics
-  end
-
-  def agent_summary
-    render json: agent_summary_metrics
-  end
-
-  private
-
-  def report_exception
-    yield
-  rescue InvalidIdentity, IdentityNotFound, MetricNotFound, InvalidStartTime, InvalidEndTime => e
-    render_error_response(e)
-  end
-
-  def current_account
-    current_user.account
-  end
-
-  def account_summary_metrics
-    summary_metrics(ACCOUNT_METRICS, :account_summary_params, AVG_ACCOUNT_METRICS)
-  end
-
-  def agent_summary_metrics
-    summary_metrics(AGENT_METRICS, :agent_summary_params, AVG_AGENT_METRICS)
-  end
-
-  def summary_metrics(metrics, calc_function, avg_metrics)
-    metrics.each_with_object({}) do |metric, result|
-      data = ReportBuilder.new(current_account, send(calc_function, metric)).build
-      result[metric] = calculate_metric(data, metric, avg_metrics)
-    end
-  end
-
-  def calculate_metric(data, metric, avg_metrics)
-    sum = data.inject(0) { |val, hash| val + hash[:value].to_i }
-    if avg_metrics.include?(metric)
-      sum /= data.length unless sum.zero?
-    end
-    sum
-  end
-
-  def account_summary_params(metric)
-    {
-      metric: metric.to_s,
-      type: :account,
-      since: params[:since],
-      until: params[:until]
-    }
-  end
-
-  def agent_summary_params(metric)
-    {
-      metric: metric.to_s,
-      type: :agent,
-      since: params[:since],
-      until: params[:until],
-      id: params[:id]
-    }
-  end
-
-  def account_report_params
-    {
-      metric: params[:metric],
-      type: :account,
-      since: params[:since],
-      until: params[:until]
-    }
-  end
-
-  def agent_report_params
-    {
-      metric: params[:metric],
-      type: :agent,
-      id: params[:id],
-      since: params[:since],
-      until: params[:until]
-    }
-  end
-end

app/dispatchers/async_dispatcher.rb

@@ -9,7 +9,7 @@ class AsyncDispatcher < BaseDispatcher
   end
 
   def listeners
-    listeners = [EventListener.instance, ReportingListener.instance, WebhookListener.instance]
+    listeners = [EventListener.instance, WebhookListener.instance]
     listeners << SubscriptionListener.instance if ENV['BILLING_ENABLED']
     listeners
   end

app/identities/account_identity.rb

@@ -1,10 +0,0 @@
-class AccountIdentity < Nightfury::Identity::Base
-  metric :conversations_count, :count_time_series, store_as: :b, step: :day
-  metric :incoming_messages_count, :count_time_series, step: :day
-  metric :outgoing_messages_count, :count_time_series, step: :day
-  metric :avg_first_response_time, :avg_time_series, store_as: :d, step: :day
-  metric :avg_resolution_time, :avg_time_series, store_as: :f, step: :day
-  metric :resolutions_count, :count_time_series, store_as: :g, step: :day
-end
-
-AccountIdentity.store_as = :ci

app/identities/agent_identity.rb

@@ -1,8 +0,0 @@
-class AgentIdentity < Nightfury::Identity::Base
-  metric :avg_first_response_time, :avg_time_series, store_as: :d, step: :day
-  metric :avg_resolution_time, :avg_time_series, store_as: :f, step: :day
-  metric :resolutions_count, :count_time_series, store_as: :g, step: :day
-  tag :account_id, store_as: :co
-end
-
-AgentIdentity.store_as = :ai