workarea-core 3.4.45 → 3.5.0.beta.1

data/app/workers/sidekiq/callbacks.rb

@@ -7,54 +7,6 @@ module Sidekiq
     class InvalidConfiguration < RuntimeError; end
 
     class << self
-      # The list of workers that perform Sidekiq callbacks. Used for checking
-      # whether one of them need to be fired off after a callback happens.
-      #
-      # @private
-      # @return [Array<Class>]
-      #
-      def workers
-        caching_classes? ? workers_list : workers_list.map(&:constantize)
-      end
-
-      # Add a {Class} to the list of workers to check when running callbacks.
-      #
-      # @private
-      # @param [Class] worker
-      #
-      def add_worker(klass)
-        if caching_classes?
-          workers_list << klass
-        elsif !workers_list.include?(klass.name)
-          workers_list << klass.name
-        end
-      end
-
-      # Whether Rails is caching classes, which matters when checking workers to
-      # run by comparing the worker's configuration with the model running the
-      # callback.
-      #
-      # When we aren't caching classes, we need to use the fully qualified
-      # constant name to decide since the classes could have been reloaded due
-      # to code changes.
-      #
-      # @return [Boolean]
-      #
-      def caching_classes?
-        ::Rails.application.config.cache_classes
-      end
-
-      # Convenience reference to the tracked list of workers in the Rails config
-      #
-      # @private
-      # @return [Array<String,Class>]
-      #
-      def workers_list
-        config = ::Rails.application.config
-        config.sidekiq_callbacks_workers = [] unless config.respond_to?(:sidekiq_callbacks_workers)
-        config.sidekiq_callbacks_workers
-      end
-
       # Permanently or temporarily enable callback workers. If
       # no workers are given, it will enable all callback
       # workers during the execution of the block or globally if no
@@ -196,7 +148,7 @@ module Sidekiq
       # finds a problem.
       #
       def assert_valid_config!
-        Sidekiq::Callbacks.workers.each do |worker|
+        Sidekiq::CallbacksWorker.workers.each do |worker|
           if (worker.enqueue_on.values.flatten & [:find, 'find']).any?
             raise(
               InvalidConfiguration,
@@ -209,7 +161,7 @@ module Sidekiq
       private
 
       def set_workers(workers, action)
-        workers = Sidekiq::Callbacks.workers if workers.blank?
+        workers = Sidekiq::CallbacksWorker.workers if workers.blank?
 
         if !block_given?
           workers.each(&action)
@@ -245,7 +197,7 @@ module Sidekiq
     private
 
     def _enqueue_callback_workers(kind)
-      Sidekiq::Callbacks.workers.select(&:enabled?).each do |worker|
+      Sidekiq::CallbacksWorker.workers.select(&:enabled?).each do |worker|
         worker.callbacks.each do |klass, callbacks|
           if _perform_callback_worker?(klass, callbacks, kind, worker)
             args = worker.find_callback_args(self)
@@ -267,7 +219,7 @@ module Sidekiq
     end
 
     def _is_a_callback_type_match?(model_class)
-      return is_a?(model_class) if Sidekiq::Callbacks.caching_classes?
+      return is_a?(model_class) if ::Rails.application.config.cache_classes
 
       # This is a funny way of doing the same check as `is_a?`.
       #

data/app/workers/sidekiq/callbacks_worker.rb

@@ -4,17 +4,15 @@ module Sidekiq
   module CallbacksWorker
     extend ActiveSupport::Concern
 
+    mattr_accessor :workers
+    self.workers = []
+
     included do
       thread_cattr_accessor :enabled, :inlined
-      Sidekiq::Callbacks.add_worker(self)
+      CallbacksWorker.workers << self
     end
 
     class_methods do
-      # @deprecated TODO remove this in v3.6
-      def workers
-        Sidekiq::Callbacks.workers
-      end
-
       def enabled?
         enabled.nil? || !!enabled
       end

data/app/workers/workarea/bulk_index_admin.rb

@@ -6,14 +6,14 @@ module Workarea
 
     class << self
       def perform(klass, ids)
-        ids.each_slice(100) do |group|
+        ids.each_slice(Workarea.config.bulk_index_batch_size) do |group|
           perform_by_models(klass.constantize.in(id: group).to_a)
         end
       end
 
       def perform_by_models(models)
         return if models.empty?
-        Workarea::Search::Admin.bulk { documents_for(models) }
+        Workarea::Search::Admin.bulk(documents_for(models))
       end
 
       private

data/app/workers/workarea/bulk_index_products.rb

@@ -6,20 +6,21 @@ module Workarea
 
     class << self
       def perform(ids = Catalog::Product.pluck(:id))
-        ids.each_slice(100) do |group|
+        ids.each_slice(Workarea.config.bulk_index_batch_size) do |group|
           perform_by_models(Catalog::Product.in(id: group).to_a)
         end
       end
 
       def perform_by_models(products)
         return if products.blank?
+        products = Array.wrap(products)
 
-        Search::Storefront.bulk do
-          Search::ProductEntries.new(products).map(&:as_bulk_document)
-        end
+        documents = Search::ProductEntries.new(products).map(&:as_bulk_document)
+        Search::Storefront.bulk(documents)
 
-        products.each { |p| p.set(last_indexed_at: Time.current) }
+        Catalog::Product.in(id: products.map(&:id)).set(last_indexed_at: Time.current)
       end
+      alias_method :perform_by_model, :perform_by_models
     end
 
     def perform(ids)

data/app/workers/workarea/bulk_index_searches.rb

@@ -4,7 +4,7 @@ module Workarea
 
     class << self
       def perform(ids = popular_searches.pluck(:id))
-        ids.each_slice(100) do |group|
+        ids.each_slice(Workarea.config.bulk_index_batch_size) do |group|
           perform_by_models(Metrics::SearchByWeek.in(id: group).to_a)
         end
       end
@@ -18,11 +18,11 @@ module Workarea
       end
 
       def perform_by_models(searches)
-        Search::Storefront.bulk do
-          searches.map do |model|
-            Search::Storefront::Search.new(model).as_bulk_document
-          end
+        documents = searches.map do |model|
+          Search::Storefront::Search.new(model).as_bulk_document
         end
+
+        Search::Storefront.bulk(documents)
       end
     end
 

data/app/workers/workarea/deactivate_stale_discounts.rb

@@ -29,9 +29,9 @@ module Workarea
 
     def all_active_discount_ids
       Pricing::Discount
-        .where(:updated_at.lt => Workarea.config.discount_staleness_ttl.ago)
-        .active
-        .pluck(:id)
+        .where(:created_at.lt => Workarea.config.discount_staleness_ttl.ago)
+        .select(&:active?)
+        .map(&:id)
         .map(&:to_s)
     end
   end

data/app/workers/workarea/generate_insights.rb

@@ -25,7 +25,7 @@ module Workarea
         Metrics::ProductByWeek.append_last_week!
         Metrics::SearchForLastWeek.aggregate!
         Metrics::SearchByWeek.append_last_week!
-        Metrics::User.update_aggregations!
+        Metrics::UpdateUserAggregations.update!
         Insights::Base.subclasses.each(&:generate_weekly!)
       end
 

data/app/workers/workarea/index_admin_search.rb

@@ -6,6 +6,7 @@ module Workarea
     sidekiq_options(
       queue: 'low',
       lock: :until_executing,
+      query_cache: true,
       enqueue_on: {
         ApplicationDocument => [:save, :touch, :destroy],
         with: -> { [self.class.name, id] },

data/app/workers/workarea/index_categorization.rb

@@ -4,16 +4,13 @@ module Workarea
     include Sidekiq::CallbacksWorker
 
     sidekiq_options(
-      enqueue_on: { Catalog::Category => :save },
-      lock: :until_executing
+      enqueue_on: { Catalog::Category => [:save, :save_release_changes] },
+      lock: :until_executing,
+      query_cache: true
     )
 
     def self.perform(category)
-      Search::Storefront::Product.delete_category(category.id)
-
-      return unless category.product_rules.present?
-
-      Search::Storefront::Product.add_category(category)
+      Search::Storefront::CategoryQuery.new(category).update
     end
 
     def perform(id)

data/app/workers/workarea/index_category.rb

@@ -5,7 +5,8 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: { Catalog::Category => [:save, :destroy] },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(id)

data/app/workers/workarea/index_category_changes.rb

@@ -4,9 +4,10 @@ module Workarea
     include Sidekiq::CallbacksWorker
 
     sidekiq_options(
-      enqueue_on: { Catalog::Category => :save, with: -> { [changes] } },
+      enqueue_on: { Catalog::Category => [:save, :save_release_changes], with: -> { [changes] } },
       ignore_if: -> { changes['product_ids'].blank? },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(changes)
@@ -15,11 +16,15 @@ module Workarea
       ids = require_index_ids(*changes['product_ids'])
 
       if ids.size > max_count
-        ids.each_slice(max_count) do |ids|
-          BulkIndexProducts.perform_async(ids)
-        end
+        ids.each { |id| IndexProduct.perform_async(id) }
       else
-        BulkIndexProducts.perform(ids)
+        Catalog::Product.in(id: ids).each do |product|
+          begin
+            IndexProduct.perform(product)
+          rescue
+            IndexProduct.perform_async(product.id)
+          end
+        end
       end
     end
 

data/app/workers/workarea/index_fulfillment_changes.rb

@@ -5,7 +5,8 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: { Fulfillment => :save }, queue: 'low',
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(order_id)

data/app/workers/workarea/index_help.rb

@@ -4,7 +4,8 @@ module Workarea
     include Sidekiq::CallbacksWorker
 
     sidekiq_options(
-      enqueue_on: { Help::Article => [:save, :destroy] }
+      enqueue_on: { Help::Article => [:save, :destroy] },
+      query_cache: true
     )
 
     def perform(id)

data/app/workers/workarea/index_page.rb

@@ -5,7 +5,8 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: { Content::Page => [:save, :destroy] },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(id)

data/app/workers/workarea/index_payment_transactions.rb

@@ -9,7 +9,8 @@ module Workarea
         with: -> { [payment_id] },
         ignore_if: -> { !success? }
       },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(order_id)

data/app/workers/workarea/index_product.rb

@@ -4,14 +4,14 @@ module Workarea
     include Sidekiq::CallbacksWorker
 
     sidekiq_options(
-      enqueue_on: { Catalog::Product => [:save, :destroy] },
-      lock: :until_executing
+      enqueue_on: { Catalog::Product => [:save, :save_release_changes, :destroy] },
+      lock: :until_executing,
+      query_cache: true
     )
 
     class << self
       def perform(product)
-        Search::ProductEntries.new(product).each(&:save)
-        product.set(last_indexed_at: Time.current)
+        BulkIndexProducts.perform_by_model(product)
       end
     end
 

data/app/workers/workarea/index_product_children.rb

@@ -5,11 +5,12 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: {
-        Catalog::Variant => [:save, :destroy],
-        Catalog::ProductImage => [:save, :destroy],
+        Catalog::Variant => [:save, :save_release_changes, :destroy],
+        Catalog::ProductImage => [:save, :save_release_changes, :destroy],
         with: -> { [_parent.id.to_s] }
       },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(id)

data/app/workers/workarea/index_product_rule.rb

@@ -5,13 +5,14 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: {
-        ProductRule => %i[save destroy],
+        ProductRule => %i[save save_release_changes destroy],
         ignore_if: -> {
           product_list.class.name != 'Workarea::Catalog::Category'
         },
         with: -> { [product_list.id] }
       },
-      unique: :until_executing
+      unique: :until_executing,
+      query_cache: true
     )
 
     def perform(id)

data/app/workers/workarea/index_search_customizations.rb

@@ -5,10 +5,11 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: {
-        Search::Customization => [:save, :destroy],
+        Search::Customization => [:save, :save_release_changes, :destroy],
         with: -> { [product_ids] }
       },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(product_ids)

data/app/workers/workarea/index_skus.rb

@@ -5,16 +5,15 @@ module Workarea
 
     sidekiq_options(
       enqueue_on: {
-        Inventory::Sku => [:touch, :save, :destroy],
-        Pricing::Sku => [:touch, :save, :destroy]
+        Inventory::Sku => [:touch, :save, :save_release_changes, :destroy],
+        Pricing::Sku => [:touch, :save, :save_release_changes, :destroy]
       },
-      lock: :until_executing
+      lock: :until_executing,
+      query_cache: true
     )
 
     def perform(sku)
-      Catalog::Product.find_for_update_by_sku(sku).each do |product|
-        IndexProduct.perform(product)
-      end
+      BulkIndexProducts.perform_by_models(Catalog::Product.find_for_update_by_sku(sku))
     end
   end
 end

data/app/workers/workarea/keep_product_index_fresh.rb

@@ -4,15 +4,13 @@ module Workarea
 
     sidekiq_options(
       lock: :until_executing,
-      retry: false
+      retry: false,
+      query_cache: true
     )
 
     def perform(*args)
       all = never_indexed + stale
-
-      all.take(Workarea.config.stale_products_size).each do |product|
-        IndexProduct.perform(product)
-      end
+      BulkIndexProducts.perform_by_models(all.take(Workarea.config.stale_products_size))
     end
 
     def never_indexed

data/app/workers/workarea/process_import.rb

@@ -17,11 +17,11 @@ module Workarea
       import.process!
 
     ensure
-      if import&.error?
+      if import.error?
         Admin::DataFileMailer.import_error(id).deliver_now
-      elsif import&.failure?
+      elsif import.failure?
         Admin::DataFileMailer.import_failure(id).deliver_now
-      elsif import.present?
+      else
         Admin::DataFileMailer.import(id).deliver_now
       end
     end

data/app/workers/workarea/process_search_recommendations.rb

@@ -7,10 +7,10 @@ module Workarea
 
       start = Workarea.config.recommendation_expiration.ago
 
-      Recommendation::UserActivity
+      Metrics::User
         .where(:updated_at.gte => start)
         .desc(:updated_at) # sort by updated_at to ensure use of that index
-        .each_by(page_size) { |activity| add(activity) }
+        .each_by(page_size) { |metrics| add(metrics) }
 
       predictor.process!
     end
@@ -19,13 +19,9 @@ module Workarea
       @predictor ||= Recommendation::SearchPredictor.new
     end
 
-    def add(activity)
-      searches = activity
-                  .searches
-                  .map { |s| QueryString.new(s).id }
-                  .reject(&:blank?)
-
-      predictor.sessions.add_set(activity.id.to_s, searches) if searches.many?
+    def add(metrics)
+      return unless metrics.viewed.search_ids.many?
+      predictor.sessions.add_set(metrics.id, metrics.viewed.search_ids)
     end
 
     def page_size

data/app/workers/workarea/publish_release.rb

@@ -1,6 +1,7 @@
 module Workarea
   class PublishRelease
     include Sidekiq::Worker
+    sidekiq_options queue: 'releases'
 
     def perform(release_id)
       release = Release.find(release_id)

data/app/workers/workarea/save_metrics.rb

@@ -0,0 +1,116 @@
+module Workarea
+  module SaveMetrics
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def save_sales(metrics)
+        Metrics::SalesByDay.inc(at: metrics.occured_at, **metrics.sales_data)
+      end
+
+      def save_catalog(metrics)
+        save_products(metrics)
+        save_categories(metrics)
+        save_skus(metrics)
+      end
+
+      def save_products(metrics)
+        metrics.products.each do |product_id, data|
+          Metrics::ProductByDay.inc(
+            key: { product_id: product_id },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+
+      def save_categories(metrics)
+        metrics.categories.each do |category_id, data|
+          Metrics::CategoryByDay.inc(
+            key: { category_id: category_id },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+
+      def save_skus(metrics)
+        metrics.skus.each do |sku, data|
+          Metrics::SkuByDay.inc(
+            key: { sku: sku },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+
+      def save_traffic(metrics)
+        save_country(metrics)
+        save_searches(metrics)
+        save_traffic_referrer(metrics)
+      end
+
+      def save_country(metrics)
+        if metrics.country.present?
+          Metrics::CountryByDay.inc(
+            key: { country: metrics.country },
+            at: metrics.occured_at,
+            **metrics.sales_data
+          )
+        end
+      end
+
+      def save_searches(metrics)
+        metrics.searches.each do |query_id, data|
+          Metrics::SearchByDay.inc(
+            key: { query_id: query_id },
+            at: metrics.occured_at,
+            **metrics.sales_data
+          )
+        end
+      end
+
+      def save_traffic_referrer(metrics)
+        if metrics.traffic_referrer.present?
+          Metrics::TrafficReferrerByDay.inc(
+            key: {
+              medium: metrics.traffic_referrer.medium,
+              source: metrics.traffic_referrer.source
+            },
+            at: metrics.occured_at,
+            **metrics.sales_data
+          )
+        end
+      end
+
+      def save_pricing(metrics)
+        metrics.discounts.each do |discount_id, data|
+          Metrics::DiscountByDay.inc(
+            key: { discount_id: discount_id },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+
+      def save_tenders(metrics)
+        metrics.tenders.each do |tender, data|
+          Metrics::TenderByDay.inc(
+            key: { tender: tender },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+
+      def save_segments(metrics)
+        metrics.segments.each do |segment_id, data|
+          Metrics::SegmentByDay.inc(
+            key: { segment_id: segment_id },
+            at: metrics.occured_at,
+            **data
+          )
+        end
+      end
+    end
+  end
+end

data/app/workers/workarea/save_order_cancellation_metrics.rb

@@ -0,0 +1,35 @@
+module Workarea
+  class SaveOrderCancellationMetrics
+    include Sidekiq::Worker
+    include SaveMetrics
+
+    class << self
+      def perform(order, cancel_data = {})
+        metrics = OrderCancellationMetrics.new(
+          order,
+          **cancel_data.symbolize_keys
+        )
+
+        save_sales(metrics)
+        save_user(metrics)
+        save_products(metrics)
+        save_skus(metrics)
+        save_country(metrics)
+        save_segments(metrics)
+
+        order.metrics_saved!
+      end
+
+      def save_user(metrics)
+        Metrics::User.save_cancellation(
+          at: metrics.occured_at,
+          **metrics.user_data
+        )
+      end
+    end
+
+    def perform(order_id, cancel_data = {})
+      self.class.perform(Order.find(order_id), cancel_data)
+    end
+  end
+end