fcm 2.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ddf83437f7c8df20298ffa3f334473e0032032e7f8e88d5021185f448f4606
-  data.tar.gz: fc79d5369ee5b22b854f49889a69de1612c4c7e2a37ec17683b8a428a0326549
+  metadata.gz: f15e3ef0efb046941ee9c8e615206668feb9e0f087e03be74b25303d40a8ebfe
+  data.tar.gz: 492c261d5f4d58a0511d809aa7ad7278fdc18462590459ec8027a7215b146724
 SHA512:
-  metadata.gz: 9b37b2f37b95cc0816547c973872c8c17c3905602fe8162bff2e25e3a52c7997f7dae11c472a399c8d947e9bfdde668b3223f793b912d274f4bcd204ba827325
-  data.tar.gz: 06f380df29d1bcc8683df25f45c099c8615609081308de79c0966c52ea9f4f887155ee77591b65ad479260d736b5e2b98f682e4616bce19cfc52c937995015ad
+  metadata.gz: fd794a9f1aedf3f82ae9c1e43f299ab8be6a432738383d6db2d8fc1add8b44577e50ee1563d00bd7878d801e2eff46994b9a84d06b18a9b4892d2d6d9146a950
+  data.tar.gz: bd237deb478ab400e9e8e82cc6679c6c2560727757c8a74b25a2db51df7473b012f00b8019402f7426c601a31710dcdd28710cab9b1e96de132bdbd41b31e109

data/.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.7', '3.0', '3.1', '3.3']
+        ruby: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4', '4.0']
 
     steps:
       - uses: actions/checkout@master
@@ -28,3 +28,18 @@ jobs:
       - name: Run tests
         run: |
           bundle exec rspec
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler: default
+          bundler-cache: true
+
+      - name: Run RuboCop
+        run: bundle exec rubocop --parallel

data/.hound.yml

@@ -0,0 +1,2 @@
+rubocop:
+  enabled: false

data/.rubocop.yml

@@ -0,0 +1,67 @@
+plugins:
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 2.7
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - "vendor/**/*"
+    - "tmp/**/*"
+
+# This is a small gem; some style cops add noise without value.
+Style/Documentation:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+# Renaming `is_not_registered?` / `has_canonical_id?` would change the gem's
+# (admittedly internal) Ruby surface area. Out of scope for a lint pass.
+Naming/PredicatePrefix:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - "fcm.gemspec"
+
+# Out of scope for a lint pass: bumping required_ruby_version is a semver-relevant
+# change for gem consumers and should be considered separately.
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
+# Enabling MFA is a publishing-policy decision for the gem maintainer, not
+# something a lint pass should silently introduce.
+Gemspec/RequireMFA:
+  Enabled: false
+
+# Code metrics are coarse signals that fight a lot of legacy code.
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "fcm.gemspec"
+
+# Specs are intentionally long, descriptive, and use `.should` syntax in
+# places — none of these add value here.
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+RSpec/NestedGroups:
+  Enabled: false
+RSpec/NoExpectationExample:
+  Enabled: false

data/Gemfile

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 gemspec
 
-gem 'rake'
-gem 'rspec'
-gem 'webmock'
-gem 'ci_reporter_rspec'
-gem 'googleauth'
+gem "ci_reporter_rspec"
+gem "rake"
+gem "rspec"
+gem "rubocop", require: false
+gem "rubocop-rspec", require: false
+gem "webmock"

data/README.md

@@ -54,6 +54,39 @@ fcm = FCM.new(
 
 ```
 
+## Request timeouts
+
+Both the read timeout and the TCP connect timeout are configurable via
+`http_options`. Both default to `DEFAULT_TIMEOUT` (30s):
+
+```ruby
+fcm = FCM.new(
+  GOOGLE_APPLICATION_CREDENTIALS_PATH,
+  FIREBASE_PROJECT_ID,
+  timeout: 10,      # response read timeout
+  open_timeout: 5   # TCP connect timeout — fail fast on stuck handshakes
+)
+```
+
+## HTTP keep-alive
+
+By default each request opens a fresh TCP/TLS connection to FCM. For high-volume
+senders this dominates per-request latency. Pass `keep_alive_connections: true`
+to reuse a thread-local connection (per host) backed by `net-http-persistent`:
+
+```ruby
+fcm = FCM.new(
+  GOOGLE_APPLICATION_CREDENTIALS_PATH,
+  FIREBASE_PROJECT_ID,
+  keep_alive_connections: true,
+  keep_alive_idle_timeout_seconds: 30, # optional, default 30
+  keep_alive_pool_size: 1              # optional, default 1
+)
+```
+
+`Net::HTTP` is not thread-safe, so connections are cached per `(thread, uri)`.
+Connections are dropped on error so half-closed sockets are not reused.
+
 ## Usage
 
 ## HTTP v1 API
@@ -274,6 +307,16 @@ The guide to set up an iOS app to get notifications is here: [Setting up a FCM C
 
 ## ChangeLog
 
+### 2.0.3
+- Add opt-in HTTP keep-alive via `keep_alive_connections` [#145](https://github.com/decision-labs/fcm/pull/145)
+- Add configurable `open_timeout` via `http_options` [#146](https://github.com/decision-labs/fcm/pull/146)
+- Cover modern Ruby versions in the CI test matrix [#147](https://github.com/decision-labs/fcm/pull/147)
+- Replace Hound with RuboCop [#148](https://github.com/decision-labs/fcm/pull/148)
+- Drop unused `cgi` require and duplicate Gemfile `googleauth` [#149](https://github.com/decision-labs/fcm/pull/149)
+
+### 2.0.2
+- Ensure JSON key path is an actual file or IO object before opening [#134](https://github.com/spacialdb/fcm/pull/134)
+
 ### 2.0.1
 - Add `http_options` to `initialize` method and whitelist `timeout` option
 

data/Rakefile

@@ -1,15 +1,17 @@
-require 'rspec/core/rake_task'
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
 require "bundler/gem_tasks"
 require "rake/tasklib"
-require 'ci/reporter/rake/rspec'
+require "ci/reporter/rake/rspec"
 
-RSpec::Core::RakeTask.new(:spec => ["ci:setup:rspec"]) do |t|
-  t.pattern = 'spec/**/*_spec.rb'
+RSpec::Core::RakeTask.new(spec: ["ci:setup:rspec"]) do |t|
+  t.pattern = "spec/**/*_spec.rb"
 end
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rspec_opts = ['--format documentation']
+  spec.pattern = "spec/**/*_spec.rb"
+  spec.rspec_opts = ["--format documentation"]
 end
 
-task :default => :spec
+task default: :spec

data/fcm.gemspec

@@ -1,24 +1,26 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path("lib", __dir__)
 
 Gem::Specification.new do |s|
   s.name = "fcm"
-  s.version = "2.0.1"
+  s.version = "2.0.3"
   s.platform = Gem::Platform::RUBY
   s.authors = ["Kashif Rasul", "Shoaib Burq"]
   s.email = ["kashif@decision-labs.com", "shoaib@decision-labs.com"]
   s.homepage = "https://github.com/decision-labs/fcm"
-  s.summary = %q{Reliably deliver messages and notifications via FCM}
-  s.description = %q{fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform messaging solution that lets you reliably deliver messages and notifications at no cost to Android, iOS or Web browsers.}
+  s.summary = "Reliably deliver messages and notifications via FCM"
+  s.description = "fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform messaging solution that lets you reliably deliver messages and notifications at no cost to Android, iOS or Web browsers."
   s.license = "MIT"
 
   s.required_ruby_version = ">= 2.4.0"
 
   s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency("faraday", ">= 1.0.0", "< 3.0")
-  s.add_runtime_dependency("googleauth", "~> 1")
+  s.add_dependency("faraday", ">= 1.0.0", "< 3.0")
+  s.add_dependency("faraday-net_http_persistent", "~> 2.0")
+  s.add_dependency("googleauth", "~> 1")
+  s.add_dependency("net-http-persistent", "~> 4.0")
 end

data/lib/fcm.rb

@@ -1,21 +1,36 @@
+# frozen_string_literal: true
+
 require "faraday"
-require "cgi"
 require "json"
 require "googleauth"
 
 class FCM
+  class InvalidCredentialError < StandardError; end
+
   BASE_URI = "https://fcm.googleapis.com"
   BASE_URI_V1 = "https://fcm.googleapis.com/v1/projects/"
   DEFAULT_TIMEOUT = 30
+  DEFAULT_KEEP_ALIVE_IDLE_TIMEOUT_SECONDS = 30
+  DEFAULT_KEEP_ALIVE_POOL_SIZE = 1
 
   GROUP_NOTIFICATION_BASE_URI = "https://android.googleapis.com"
   INSTANCE_ID_API = "https://iid.googleapis.com"
-  TOPIC_REGEX = /[a-zA-Z0-9\-_.~%]+/
+  TOPIC_REGEX = /[a-zA-Z0-9\-_.~%]+/.freeze
 
   def initialize(json_key_path = "", project_name = "", http_options = {})
     @json_key_path = json_key_path
     @project_name = project_name
     @http_options = http_options
+    @keep_alive_connections = http_options.fetch(:keep_alive_connections, false)
+    @keep_alive_idle_timeout_seconds =
+      http_options.fetch(:keep_alive_idle_timeout_seconds, DEFAULT_KEEP_ALIVE_IDLE_TIMEOUT_SECONDS)
+    @keep_alive_pool_size = http_options.fetch(:keep_alive_pool_size, DEFAULT_KEEP_ALIVE_POOL_SIZE)
+
+    # Per-instance key for the thread-local connection cache so multiple FCM
+    # clients in the same process do not share sockets.
+    @thread_connections_key = :"_fcm_connections_#{object_id}"
+
+    require "faraday/net_http_persistent" if @keep_alive_connections
   end
 
   # See https://firebase.google.com/docs/cloud-messaging/send-message
@@ -49,7 +64,7 @@ class FCM
   def send_notification_v1(message)
     return if @project_name.empty?
 
-    post_body = { 'message': message }
+    post_body = { message: message }
     for_uri(BASE_URI_V1) do |connection|
       response = connection.post(
         "#{@project_name}/messages:send", post_body.to_json
@@ -65,7 +80,7 @@ class FCM
                                                   notification_key_name: key_name)
 
     extra_headers = {
-      "project_id" => project_id,
+      "project_id" => project_id
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
@@ -82,7 +97,7 @@ class FCM
                                                   notification_key: notification_key)
 
     extra_headers = {
-      "project_id" => project_id,
+      "project_id" => project_id
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
@@ -99,7 +114,7 @@ class FCM
                                                   notification_key: notification_key)
 
     extra_headers = {
-      "project_id" => project_id,
+      "project_id" => project_id
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
@@ -114,7 +129,7 @@ class FCM
     params = { notification_key_name: key_name }
 
     extra_headers = {
-      "project_id" => project_id,
+      "project_id" => project_id
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
@@ -137,11 +152,11 @@ class FCM
   end
 
   def batch_topic_subscription(topic, registration_tokens)
-    manage_topics_relationship(topic, registration_tokens, 'Add')
+    manage_topics_relationship(topic, registration_tokens, "Add")
   end
 
   def batch_topic_unsubscription(topic, registration_tokens)
-    manage_topics_relationship(topic, registration_tokens, 'Remove')
+    manage_topics_relationship(topic, registration_tokens, "Remove")
   end
 
   def manage_topics_relationship(topic, registration_tokens, action)
@@ -163,47 +178,101 @@ class FCM
   end
 
   def send_to_topic(topic, options = {})
-    if topic.gsub(TOPIC_REGEX, '').length.zero?
-      body = { 'message': { 'topic': topic }.merge(options) }
-
-      for_uri(BASE_URI_V1) do |connection|
-        response = connection.post(
-          "#{@project_name}/messages:send", body.to_json
-        )
-        build_response(response)
-      end
+    return unless topic.gsub(TOPIC_REGEX, "").empty?
+
+    body = { message: { topic: topic }.merge(options) }
+
+    for_uri(BASE_URI_V1) do |connection|
+      response = connection.post(
+        "#{@project_name}/messages:send", body.to_json
+      )
+      build_response(response)
     end
   end
 
   def send_to_topic_condition(condition, options = {})
-    if validate_condition?(condition)
-      body = { 'message': { 'condition': condition }.merge(options) }
-
-      for_uri(BASE_URI_V1) do |connection|
-        response = connection.post(
-          "#{@project_name}/messages:send", body.to_json
-        )
-        build_response(response)
-      end
+    return unless validate_condition?(condition)
+
+    body = { message: { condition: condition }.merge(options) }
+
+    for_uri(BASE_URI_V1) do |connection|
+      response = connection.post(
+        "#{@project_name}/messages:send", body.to_json
+      )
+      build_response(response)
     end
   end
 
   private
 
-  def for_uri(uri, extra_headers = {})
-    connection = ::Faraday.new(
-      url: uri,
-      request: { timeout: @http_options.fetch(:timeout, DEFAULT_TIMEOUT) }
-    ) do |faraday|
+  def for_uri(uri, extra_headers = {}, &block)
+    if @keep_alive_connections
+      with_persistent_connection(uri, extra_headers, &block)
+    else
+      yield build_one_shot_connection(uri, extra_headers)
+    end
+  end
+
+  def build_one_shot_connection(uri, extra_headers)
+    ::Faraday.new(url: uri, request: request_options) do |faraday|
       faraday.adapter Faraday.default_adapter
-      faraday.headers["Content-Type"] = "application/json"
-      faraday.headers["Authorization"] = "Bearer #{jwt_token}"
-      faraday.headers["access_token_auth"]= "true"
-      extra_headers.each do |key, value|
-        faraday.headers[key] = value
-      end
+      apply_default_headers(faraday, extra_headers)
     end
+  end
+
+  # Reuses a thread-local Faraday connection (one per uri) backed by
+  # net-http-persistent so the TCP/TLS handshake and HTTP/2 stream are
+  # amortised across requests. Bearer tokens and per-call headers are
+  # re-applied each yield because JWTs expire and extra_headers vary.
+  # On error, the cached connection is dropped: the underlying socket may
+  # be half-closed and reusing it would just fail again.
+  def with_persistent_connection(uri, extra_headers)
+    connection = persistent_connection_for(uri)
+    apply_default_headers(connection, extra_headers)
     yield connection
+  rescue StandardError
+    discard_persistent_connection(uri)
+    raise
+  end
+
+  def apply_default_headers(connection, extra_headers)
+    connection.headers["Content-Type"] = "application/json"
+    connection.headers["Authorization"] = "Bearer #{jwt_token}"
+    connection.headers["access_token_auth"] = "true"
+    extra_headers.each { |key, value| connection.headers[key] = value }
+  end
+
+  # Net::HTTP is not thread-safe, so connections are cached per (thread, uri)
+  # rather than shared across threads.
+  def persistent_connection_for(uri)
+    thread_connections[uri] ||= build_persistent_connection(uri)
+  end
+
+  def discard_persistent_connection(uri)
+    connection = thread_connections.delete(uri)
+    connection.close if connection.respond_to?(:close)
+  end
+
+  def thread_connections
+    Thread.current[@thread_connections_key] ||= {}
+  end
+
+  def request_options
+    {
+      timeout: @http_options.fetch(:timeout, DEFAULT_TIMEOUT),
+      open_timeout: @http_options.fetch(:open_timeout, DEFAULT_TIMEOUT)
+    }
+  end
+
+  def build_persistent_connection(uri)
+    ::Faraday.new(url: uri, request: request_options) do |faraday|
+      # pool_size defaults to 1: we already cache one Faraday connection per
+      # (thread, uri), and Net::HTTP is not thread-safe — so a single socket
+      # per pool is the safe default. Override only with a specific reason.
+      faraday.adapter :net_http_persistent, pool_size: @keep_alive_pool_size do |http|
+        http.idle_timeout = @keep_alive_idle_timeout_seconds
+      end
+    end
   end
 
   def build_post_body(registration_ids, options = {})
@@ -219,9 +288,14 @@ class FCM
       response_hash[:response] = "success"
       body = JSON.parse(body) unless body.empty?
       response_hash[:canonical_ids] = build_canonical_ids(body, registration_ids) unless registration_ids.empty?
-      response_hash[:not_registered_ids] = build_not_registered_ids(body, registration_ids) unless registration_ids.empty?
+      unless registration_ids.empty?
+        response_hash[:not_registered_ids] =
+          build_not_registered_ids(body, registration_ids)
+      end
     when 400
-      response_hash[:response] = "Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields."
+      response_hash[:response] =
+        "Only applies for JSON requests. Indicates that the request could not be parsed as JSON, " \
+        "or it contained invalid fields."
     when 401
       response_hash[:response] = "There was an error authenticating the sender account."
     when 503
@@ -234,11 +308,9 @@ class FCM
 
   def build_canonical_ids(body, registration_ids)
     canonical_ids = []
-    unless body.empty?
-      if body["canonical_ids"] > 0
-        body["results"].each_with_index do |result, index|
-          canonical_ids << { old: registration_ids[index], new: result["registration_id"] } if has_canonical_id?(result)
-        end
+    if !body.empty? && body["canonical_ids"].positive?
+      body["results"].each_with_index do |result, index|
+        canonical_ids << { old: registration_ids[index], new: result["registration_id"] } if has_canonical_id?(result)
       end
     end
     canonical_ids
@@ -246,11 +318,9 @@ class FCM
 
   def build_not_registered_ids(body, registration_id)
     not_registered_ids = []
-    unless body.empty?
-      if body["failure"] > 0
-        body["results"].each_with_index do |result, index|
-          not_registered_ids << registration_id[index] if is_not_registered?(result)
-        end
+    if !body.empty? && body["failure"].positive?
+      body["results"].each_with_index do |result, index|
+        not_registered_ids << registration_id[index] if is_not_registered?(result)
       end
     end
     not_registered_ids
@@ -270,32 +340,52 @@ class FCM
 
   def validate_condition_format?(condition)
     bad_characters = condition.gsub(
-      /(topics|in|\s|\(|\)|(&&)|[!]|(\|\|)|'([a-zA-Z0-9\-_.~%]+)')/,
+      /(topics|in|\s|\(|\)|(&&)|!|(\|\|)|'([a-zA-Z0-9\-_.~%]+)')/,
       ""
     )
-    bad_characters.length == 0
+    bad_characters.empty?
   end
 
   def validate_condition_topics?(condition)
     topics = condition.scan(/(?:^|\S|\s)'([^']*?)'(?:$|\S|\s)/).flatten
-    topics.all? { |topic| topic.gsub(TOPIC_REGEX, "").length == 0 }
+    topics.all? { |topic| topic.gsub(TOPIC_REGEX, "").empty? }
   end
 
   def jwt_token
     scope = "https://www.googleapis.com/auth/firebase.messaging"
     @authorizer ||= Google::Auth::ServiceAccountCredentials.make_creds(
       json_key_io: json_key,
-      scope: scope,
+      scope: scope
     )
     token = @authorizer.fetch_access_token!
     token["access_token"]
   end
 
+  def raise_credentials_error(param)
+    error_msg = "credentials must be an IO-like " \
+                "object or path. You passed"
+
+    param_klass = param.nil? ? "nil" : "a #{param.class.name}"
+    error_msg += " #{param_klass}."
+    raise InvalidCredentialError, error_msg
+  end
+
+  def valid_json_key_path?(path)
+    valid_io_object = path.respond_to?(:open)
+    return true if valid_io_object && File.file?(path)
+
+    max_path_len = 1024
+    valid_path = path.is_a?(String) && path.length <= max_path_len
+    valid_path && File.file?(path)
+  end
+
   def json_key
     @json_key ||= if @json_key_path.respond_to?(:read)
                     @json_key_path
-                  else
+                  elsif valid_json_key_path?(@json_key_path)
                     File.open(@json_key_path)
+                  else
+                    raise_credentials_error(@json_key_path)
                   end
   end
 end