pubnub 4.0.27 → 4.0.28

data/lib/pubnub/schemas/envelope_schema.rb

@@ -39,7 +39,7 @@ module Pubnub
 
         required(:config).schema(ConfigSchema)
 
-        rule(category_value: [:error, :category]) do |error, category|
+        rule(category_value: %i[error category]) do |error, category|
           error.true?.then(category.included_in?(Pubnub::Constants::STATUS_CATEGORY_ERRORS))
           error.false?.then(category.included_in?(Pubnub::Constants::STATUS_CATEGORY_SUCCESSES))
         end

data/lib/pubnub/subscribe_callback.rb

@@ -6,8 +6,8 @@ module Pubnub
 
     def initialize(options)
       @callbacks = {
-        message:  options[:message],
-        status:   options[:status],
+        message: options[:message],
+        status: options[:status],
         presence: options[:presence]
       }
       validate!
@@ -18,7 +18,7 @@ module Pubnub
     def validate!
       # Check if each callback responds to call and accept one parameter.
       @callbacks.each do |type, callback|
-        fail "#{type} callback is not valid in SubscribeCallback." unless (callback.respond_to?(:call) && callback.arity == 1) || callback.nil?
+        raise "#{type} callback is not valid in SubscribeCallback." unless (callback.respond_to?(:call) && callback.arity == 1) || callback.nil?
       end
     end
   end

data/lib/pubnub/subscribe_event.rb

@@ -37,11 +37,9 @@ module Pubnub
 
       envelopes = finalize_event(fire_callbacks(handle(response, uri)))
 
-      async.fire unless @http_sync
+      Concurrent::Future.execute { fire } unless @http_sync
 
       envelopes
-    ensure
-      terminate if !@stay_alive && @http_sync
     end
 
     def leave_all
@@ -77,7 +75,7 @@ module Pubnub
                                           request: uri)
         end
         req
-      rescue => error
+      rescue StandardError => error
         Pubnub.logger.warn('Pubnub') { "Connection lost! Reason: #{error}" }
         @app.subscriber.announce_status(announcement_type: Pubnub::Constants::TIMEOUT_ANNOUNCEMENT,
                                         event: @event,
@@ -138,24 +136,22 @@ module Pubnub
     end
 
     def add_filter_to_params(params)
-      params.merge!('filter-expr' => encode_parameter("(#{@app.subscribe_filter})", false)) if @app.subscribe_filter
+      params['filter-expr'] = encode_parameter("(#{@app.subscribe_filter})", false) if @app.subscribe_filter
       params
     end
 
     def add_timetoken_to_params(params)
-      params.merge!(t: encode_parameter(r: @app.region_code, t: @app.timetoken))
+      params[:t] = encode_parameter(r: @app.region_code, t: @app.timetoken)
       params
     end
 
     def add_group_to_params(params)
-      params.merge!('channel-group' => @group.join(',')) unless @group.empty?
+      params['channel-group'] = @group.join(',') unless @group.empty?
       params
     end
 
     def add_state_to_params(params)
-      params.merge!(
-        state: encode_parameter(@app.env[:state][@origin][:channel].merge(@app.env[:state][@origin][:group]))
-      ) unless @app.empty_state?
+      params[:state] = encode_parameter(@app.env[:state][@origin][:channel].merge(@app.env[:state][@origin][:group])) unless @app.empty_state?
       params
     end
   end

data/lib/pubnub/subscribe_event/formatter.rb

@@ -37,7 +37,7 @@ module Pubnub
         cipher_key = compute_cipher_key(message.reject { |k, _v| k == :payload })
         crypto = Pubnub::Crypto.new(cipher_key)
         JSON.parse(crypto.decrypt(message[:payload]), quirks_mode: true)
-      rescue
+      rescue StandardError
         message[:payload]
       end
 
@@ -47,87 +47,89 @@ module Pubnub
         messages = expand_messages_keys(parsed_response['m'])
 
         # STATUS
-        if messages.empty?
-          envelopes = [
-            Pubnub::Envelope.new(
-              event: @event,
-              event_options: @given_options,
-              timetoken: expand_timetoken(timetoken),
-              status: {
-                code: req_res_objects[:response].code,
-                client_request: req_res_objects[:request],
-                server_response: req_res_objects[:response],
-                data: nil,
-                category: Pubnub::Constants::STATUS_ACK,
-                error: false,
-                auto_retried: true,
-
-                current_timetoken: timetoken['t'].to_i,
-                last_timetoken: @app.env[:timetoken].to_i,
-                subscribed_channels: @app.subscribed_channels,
-                subscribed_channel_groups: @app.subscribed_groups,
-
-                config: get_config
-
-              },
-              result: {
-                code: req_res_objects[:response].code,
-                operation: get_operation,
-                client_request: req_res_objects[:request],
-                server_response: req_res_objects[:response],
-
-                data: nil
-              }
-            )
-          ]
-        else # RESULT
-          envelopes = messages.map do |message|
-            Pubnub::Envelope.new(
-              event: @event,
-              event_options: @given_options,
-              timetoken: expand_timetoken(timetoken),
-              status: {
-                code: req_res_objects[:response].code,
-                client_request: req_res_objects[:request],
-                server_response: req_res_objects[:response],
-                data: message,
-                category: Pubnub::Constants::STATUS_ACK,
-                error: false,
-                auto_retried: true,
-
-                current_timetoken: timetoken['t'].to_i,
-                last_timetoken: @app.env[:timetoken].to_i,
-                subscribed_channels: @app.subscribed_channels,
-                subscribed_channel_groups: @app.subscribed_groups,
-
-                config: get_config
-
-              },
-              result: {
-                code: req_res_objects[:response].code,
-                operation: get_operation(message),
-                client_request: req_res_objects[:request],
-                server_response: req_res_objects[:response],
-
-                data: {
-                  message: decipher_payload(message),
-                  subscribed_channel: message[:subscription_match] || message[:channel],
-                  actual_channel: message[:channel],
-                  publish_time_object: message[:publish_timetoken],
-                  message_meta_data: message[:user_meta_data],
-                  presence_event: get_presence_event(message),
-                  presence: get_presence_data(message)
-                }
-              }
-            )
-          end
-        end
-
+        envelopes = if messages.empty?
+                      [plain_envelope(req_res_objects, timetoken)]
+                    else # RESULT
+                      messages.map do |message|
+                        encrypted_envelope(req_res_objects, message, timetoken)
+                      end
+                    end
         validate_envelopes(envelopes)
-
         envelopes
       end
 
+      def plain_envelope(req_res_objects, timetoken)
+        Pubnub::Envelope.new(
+          event: @event,
+          event_options: @given_options,
+          timetoken: expand_timetoken(timetoken),
+          status: {
+            code: req_res_objects[:response].code,
+            client_request: req_res_objects[:request],
+            server_response: req_res_objects[:response],
+            data: nil,
+            category: Pubnub::Constants::STATUS_ACK,
+            error: false,
+            auto_retried: true,
+
+            current_timetoken: timetoken['t'].to_i,
+            last_timetoken: @app.env[:timetoken].to_i,
+            subscribed_channels: @app.subscribed_channels,
+            subscribed_channel_groups: @app.subscribed_groups,
+
+            config: get_config
+          },
+          result: {
+            code: req_res_objects[:response].code,
+            operation: get_operation,
+            client_request: req_res_objects[:request],
+            server_response: req_res_objects[:response],
+
+            data: nil
+          }
+        )
+      end
+
+      def encrypted_envelope(req_res_objects, message, timetoken)
+        Pubnub::Envelope.new(
+          event: @event,
+          event_options: @given_options,
+          timetoken: expand_timetoken(timetoken),
+          status: {
+            code: req_res_objects[:response].code,
+            client_request: req_res_objects[:request],
+            server_response: req_res_objects[:response],
+            data: message,
+            category: Pubnub::Constants::STATUS_ACK,
+            error: false,
+            auto_retried: true,
+
+            current_timetoken: timetoken['t'].to_i,
+            last_timetoken: @app.env[:timetoken].to_i,
+            subscribed_channels: @app.subscribed_channels,
+            subscribed_channel_groups: @app.subscribed_groups,
+
+            config: get_config
+          },
+          result: {
+            code: req_res_objects[:response].code,
+            operation: get_operation(message),
+            client_request: req_res_objects[:request],
+            server_response: req_res_objects[:response],
+
+            data: {
+              message: decipher_payload(message),
+              subscribed_channel: message[:subscription_match] || message[:channel],
+              actual_channel: message[:channel],
+              publish_time_object: message[:publish_timetoken],
+              message_meta_data: message[:user_meta_data],
+              presence_event: get_presence_event(message),
+              presence: get_presence_data(message)
+            }
+          }
+        )
+      end
+
       def validate_envelopes(envelopes)
         # return if envelopes.size == 1 && envelopes.first.timetoken_update?
 
@@ -141,7 +143,7 @@ module Pubnub
 
         if (results_validation + statuses_validation).map(&:failure?).index(true)
           Pubnub.logger.error('Pubnub::SubscribeEvent::Formatter') { 'Invalid formatted envelope.' }
-          fail Exception, 'Invalid formatted envelope.'
+          raise Exception, 'Invalid formatted envelope.'
         end
       end
 
@@ -180,7 +182,7 @@ module Pubnub
       def get_presence_event(message)
         return nil unless get_operation(message) == Pubnub::Constants::OPERATION_PRESENCE
         message[:payload]['action']
-      rescue
+      rescue StandardError
         nil
       end
 

data/lib/pubnub/subscribe_event/heartbeat.rb

@@ -13,7 +13,7 @@ module Pubnub
       def stop_heartbeat
         Pubnub.logger.debug('Pubnub') { "#{self.class}#stop_heartbeat" }
 
-        Celluloid::Actor.kill(@heart) if @heart
+        Concurrent::Actor.kill(@heart) if @heart
         @heart = nil
       end
 

data/lib/pubnub/subscriber.rb

@@ -16,11 +16,11 @@ module Pubnub
     end
 
     def add_listener(options)
-      name     = (options[:name] || UUID.generate).to_sym
+      name = (options[:name] || UUID.generate).to_sym
       callback = options[:callback]
 
-      fail 'Invalid listener.' unless callback.is_a?(SubscribeCallback)
-      fail 'Listener with such name already exists.' if @listeners.keys.include?(name)
+      raise 'Invalid listener.' unless callback.is_a?(SubscribeCallback)
+      raise 'Listener with such name already exists.' if @listeners.key?(name)
 
       @listeners[name] = callback
     end
@@ -29,7 +29,7 @@ module Pubnub
       name = options[:name]
       callback = options[:callback]
 
-      fail 'You have to specify name _or_ listener object.' if name && callback
+      raise 'You have to specify name _or_ listener object.' if name && callback
 
       @listeners.delete_if { |k, _v| k == name.to_sym } if name
 
@@ -83,17 +83,17 @@ module Pubnub
 
     def announce_status(options)
       announcement_type = options[:announcement_type]
-      event             = options[:event]
-      given_options     = options[:given_options]
-      request           = options[:request]
-      _response         = options[:response]
+      event = options[:event]
+      given_options = options[:given_options]
+      request = options[:request]
+      _response = options[:response]
 
       case announcement_type
       when Pubnub::Constants::TIMEOUT_ANNOUNCEMENT
         envelope = ErrorEnvelope.new(
-          event:         event,
+          event: event,
           event_options: given_options,
-          timetoken:     nil,
+          timetoken: nil,
           status: {
             code: nil,
             client_request: request,
@@ -103,9 +103,9 @@ module Pubnub
             error: true,
             auto_retried: true,
 
-            current_timetoken:         @app.env[:timetoken].to_i,
-            last_timetoken:            @app.env[:timetoken].to_i,
-            subscribed_channels:       @app.subscribed_channels,
+            current_timetoken: @app.env[:timetoken].to_i,
+            last_timetoken: @app.env[:timetoken].to_i,
+            subscribed_channels: @app.subscribed_channels,
             subscribed_channel_groups: @app.subscribed_groups,
 
             config: get_config
@@ -122,9 +122,9 @@ module Pubnub
         )
       when Pubnub::Constants::RECONNECTED_ANNOUNCEMENT
         envelope = ErrorEnvelope.new(
-          event:         event,
+          event: event,
           event_options: given_options,
-          timetoken:     nil,
+          timetoken: nil,
           status: {
             code: nil,
             client_request: request,
@@ -134,9 +134,9 @@ module Pubnub
             error: false,
             auto_retried: true,
 
-            current_timetoken:         @app.env[:timetoken].to_i,
-            last_timetoken:            @app.env[:timetoken].to_i,
-            subscribed_channels:       @app.subscribed_channels,
+            current_timetoken: @app.env[:timetoken].to_i,
+            last_timetoken: @app.env[:timetoken].to_i,
+            subscribed_channels: @app.subscribed_channels,
             subscribed_channel_groups: @app.subscribed_groups,
 
             config: get_config
@@ -153,9 +153,9 @@ module Pubnub
         )
       when Pubnub::Constants::STATUS_REQUEST_MESSAGE_COUNT_EXCEEDED
         envelope = Pubnub::Envelope.new(
-          event:         event,
+          event: event,
           event_options: given_options,
-          timetoken:     nil,
+          timetoken: nil,
           status: {
             code: nil,
             client_request: request,
@@ -165,9 +165,9 @@ module Pubnub
             error: false,
             auto_retried: true,
 
-            current_timetoken:         @app.env[:timetoken].to_i,
-            last_timetoken:            @app.env[:timetoken].to_i,
-            subscribed_channels:       @app.subscribed_channels,
+            current_timetoken: @app.env[:timetoken].to_i,
+            last_timetoken: @app.env[:timetoken].to_i,
+            subscribed_channels: @app.subscribed_channels,
             subscribed_channel_groups: @app.subscribed_groups,
 
             config: get_config
@@ -253,7 +253,7 @@ module Pubnub
 
     def build_subscription
       @current_subscription = Subscribe.new({ ssl: @ssl }, @app)
-      @current_subscription_id = @current_subscription.bare_object.object_id
+      @current_subscription_id = @current_subscription.object_id
       @current_subscription.build(callbacks: @callbacks,
                                   channels: @channels,
                                   groups: @groups,
@@ -263,30 +263,29 @@ module Pubnub
     def remove_current_subscription
       return if @current_subscription_id.nil?
       Pubnub.logger.debug('Pubnub::Subscriber') { 'Removing current subscription' }
-      @current_subscription.async.terminate
-      @current_subscription    = nil
+      @current_subscription = nil
       @current_subscription_id = nil
       @app.timetoken = 0
     end
 
     def start_subscription
       Pubnub.logger.debug('Pubnub::Subscriber') { 'Starting subscription' }
-      fail 'Cannot start subscription without builded @current_subscription' if @current_subscription.nil?
-      @current_subscription.future.fire
+      raise 'Cannot start subscription without builded @current_subscription' if @current_subscription.nil?
+      @current_subscription.async.fire
     end
 
     def secure_call(cb, arg)
       cb.call arg
-    rescue => error
+    rescue StandardError => error
       Pubnub.logger.error('Pubnub::Subscriber') { "Error while calling callback #{error.inspect}" }
     end
 
     def get_config
       {
-        tls:      @app.env[:ssl],
-        uuid:     @app.env[:uuid],
+        tls: @app.env[:ssl],
+        uuid: @app.env[:uuid],
         auth_key: @app.env[:auth_key],
-        origin:   @app.current_origin
+        origin: @app.current_origin
       }
     end
   end

data/lib/pubnub/telemetry.rb

@@ -1,43 +1,42 @@
 module Pubnub
+  # Thread-safe async telemetry
   class Telemetry
-    include Celluloid
+    include Concurrent::Async
 
     def initialize
-      @timers, @good_to_go, @recorded_history = {}, {}, {}
-      Pubnub.logger.debug('Pubnub::Telementry') { 'Initialized Telemetry'}
+      @recorded_history = Concurrent::Map.new { default_telemetry }
+      Pubnub.logger.debug('Pubnub::Telementry') { 'Initialized Telemetry' }
     end
 
     def record_request(telemetry_type, time_start, time_end)
-      begin
-        @timers[telemetry_type] = every(1) { @good_to_go[telemetry_type] = true } unless @timers[telemetry_type]
-        @recorded_history[telemetry_type] ||= []
-        @recorded_history[telemetry_type] << time_end - time_start
-      rescue => error
-        Pubnub.logger.error('Pubnub::Telemetry'){ "Failed to record request #{error}\n#{error.backtrace.join("\n")}" }
+      @recorded_history.compute(telemetry_type) do |telemetry|
+        telemetry ||= default_telemetry
+        telemetry[:sum] += (time_end - time_start)
+        telemetry[:counter] += 1
+        telemetry
       end
+    rescue StandardError => error
+      Pubnub.logger.error('Pubnub::Telemetry') { "Failed to record request #{error}\n#{error.backtrace.join("\n")}" }
     end
 
     def fetch_average(telemetry_type)
-      begin
-        Pubnub.logger.debug('Pubnub::Telemetry'){ "Fetching telemetry for #{telemetry_type}" }
-        @recorded_history[telemetry_type] ||= []
-        return false if !@good_to_go[telemetry_type] || @recorded_history[telemetry_type].size == 0
-        average = @recorded_history[telemetry_type].reduce(0, :+) / @recorded_history[telemetry_type].size
-        clear!(telemetry_type)
-        Pubnub.logger.debug('Pubnub::Telemetry'){ "Current average: #{average}" }
-        average
-      rescue => error
-        Pubnub.logger.error('Pubnub::Telemetry'){ "Failed to fetch average #{error}\n#{error.backtrace.join("\n")}" }
+      Pubnub.logger.debug('Pubnub::Telemetry') { "Fetching telemetry for #{telemetry_type}" }
+      return false if @recorded_history[telemetry_type][:counter].zero?
+      average = 0
+      @recorded_history.compute(telemetry_type) do |telemetry|
+        average = telemetry[:sum].to_f / telemetry[:counter].to_f
+        default_telemetry
       end
+      Pubnub.logger.debug('Pubnub::Telemetry') { "Current average: #{average}" }
+      average
+    rescue StandardError => error
+      Pubnub.logger.error('Pubnub::Telemetry') { "Failed to fetch average #{error}\n#{error.backtrace.join("\n")}" }
     end
 
-    def clear!(telemetry_type)
-      begin
-        @recorded_history[telemetry_type] = []
-        @good_to_go[telemetry_type] = false
-      rescue => error
-        Pubnub.logger.error('Pubnub::Telemetry'){ "Failed to clear telemetry #{error}\n#{error.backtrace.join("\n")}" }
-      end
+    private
+
+    def default_telemetry
+      { sum: 0, counter: 0 }
     end
   end
-end
+end