promoted-ruby-client 0.1.23 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 280c1b17bece86732743246173338746e1ab9d414b9515bc9fc77c8c598ae319
-  data.tar.gz: 1fed11fd16de69732e6f61d1d1e33b31c812151413a34d881b8dd7aace712daa
+  metadata.gz: a3f9ec2c51749dd3819e71b93784a0eea77f4f11b0117ad21c44ae976a2b1d96
+  data.tar.gz: a507c5f00b3e3cfc8116c67f2413f51e6a9b45827f991ad44953c36b5c44b453
 SHA512:
-  metadata.gz: 997ca8c047a62a08b2f5e008184719c3e3f1f1dac45cfbccf41c4f451b8fad3f9a8aab7737e148a6281b4a9600e8c2ff6b8bfe9a269aba417ab7bf21f735fcd3
-  data.tar.gz: 274d3ce469128a6fa7da5fc127b65e9a3e1cc2327b322af5719182f06a37ada713806458c754d2efed6d6a21ad7ab945890541d5e3d1247844b66fa6b3a77a16
+  metadata.gz: 580f2c7e11d8cc30e1c2d23f2c0b57f311597af695d0179a4d32149d1e4e3723d122e8f2783ce4e1e9b0d09374779a029091106c10612920b7d0c5e942b35ebe
+  data.tar.gz: 3a75185fe166e28b551eb82fd7cbcb51cf92c1fb8fdf7a1266bbb46715fd8d190ef9df75da5ab438991dde5352c4802abd8d3ee68abf27400aa58ca40037cb8e

data/.gitignore

@@ -58,6 +58,8 @@ build-iPhoneSimulator/
 
 # IDE
 .vscode/
+.history/
 
 # Dev
-dev/
+dev/
+.history/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    promoted-ruby-client (0.1.23)
+    promoted-ruby-client (1.0.0)
       concurrent-ruby (~> 1)
       faraday (>= 0.9.0)
       faraday_middleware (>= 0.9.0)

data/README.md

@@ -54,6 +54,7 @@ Name | Type | Description
 ```:default_only_log``` | Boolean | If true, the ```deliver``` method will not direct traffic to Delivery API but rather return a request suitable for logging. Defaults to false.
 ```:should_apply_treatment_func``` | Proc | Called during delivery, accepts an experiment and returns a Boolean indicating whether the request should be considered part of the control group (false) or in the experiment (true). If nil, the default behavior of checking the experiement ```:arm``` is applied.
 ```:warmup``` | Boolean | If true, the client will prime the `Net::HTTP::Persistent` connection pool on construction; this can make the first few calls to Promoted complete faster. Defaults to false.
+```:max_request_insertions``` | Number | Maximum number of request insertions that will be passed to Delivery API on a single request (any more will be truncated by the SDK). Defaults to 1000.  
 
 ## Data Types
 
@@ -152,6 +153,7 @@ Field Name | Type | Optional? | Description
 ```:user_agent``` | String | Yes | Browser user agent string
 ```:viewport_size``` | Size | Yes | Size of the browser viewport
 ```:client_hints``` | ClientHints | Yes | HTTP client hints structure
+```referrer``` | String | Yes | Request referrer
 ---
 ### Device
 Information about the user's device.
@@ -180,13 +182,6 @@ Field Name | Type | Optional? | Description
 ```:paging``` | Paging | Yes | Paging parameters (see TODO)
 ```:device``` | Device | Yes | Device information (as available)
 ---
-### MetricsRequest
-Input to ```prepare_for_logging```
-Field Name | Type | Optional? | Description
----------- | ---- | --------- | -----------
-```:request``` | Request | No | The underlying request for content.
-```:full_insertion``` | [] of Insertion | No | The proposed list of insertions.
----
 
 ### DeliveryRequest
 Input to ```deliver```
@@ -194,7 +189,6 @@ Field Name | Type | Optional? | Description
 ---------- | ---- | --------- | -----------
 ```:experiment``` | CohortMembership | Yes | A cohort to evaluation in experimentation.
 ```:request``` | Request | No | The underlying request for content.
-```:full_insertion``` | [] of Insertion | No | The proposed list of insertions with all metadata, will be compacted before forwarding to Promoted.
 ```:only_log``` | Boolean | Yes | Defaults to false. Set to true to override whether Delivery API is called for this request.
 ---
 
@@ -286,28 +280,20 @@ metrics_request = {
       :struct => {
         :active => true
       }
-    }
+    },
+    :insertion => insertions
   },
-  :full_insertion => insertions
+  :only_log => true,
 }
 
-# OPTIONAL: You can pass a custom function to "compact" insertions before metrics logging.
-# Note that the PromotedClient has a class method helper, remove_all_properties, that does
-# an implementation of this, returning nil to remove ALL properties.
-to_compact_metrics_properties_func = Proc.new do |properties|
-  properties[:struct].delete(:active)
-  properties
-end
-# metrics_request[:to_compact_metrics_properties_func] = to_compact_metrics_properties_func
-
 # Create a client
 client = Promoted::Ruby::Client::PromotedClient.new
 
 # Build a log request
-log_request = client.prepare_for_logging(metrics_request)
+client_response = client.deliver(metrics_request)
 
 # Log (assuming you have configured your client with a :metrics_endpoint)
-client.send_log_request(log_request)
+client.send_log_request(client_response[:log_request]) if client_response[:log_request]
 ```
 
 ## Delivery API
@@ -330,9 +316,9 @@ delivery_request = {
       :struct => {
         :active => true
       }
-    }
+    },
+    :insertion => insertions,
   },
-  :full_insertion => insertions,
   :only_log => false
 }
 

data/dev.md

@@ -4,5 +4,5 @@
 2. Get credentials for deployment from 1password.
 3. Modify `promoted-ruby-client.gemspec`'s push block.
 4. Run `gem build promoted-ruby-client.gemspec` to generate `gem`.
-5. Run (using new output) `gem push promoted-ruby-client-0.1.23.gem`
+5. Run (using new output) `gem push promoted-ruby-client-1.0.0.gem`
 6. Update README with new version.

data/lib/promoted/ruby/client/request_builder.rb

@@ -3,10 +3,9 @@ module Promoted
     module Client
       class RequestBuilder
         attr_reader   :session_id, :only_log, :experiment, :client_info, :device,
-                      :view_id, :insertion, :to_compact_delivery_properties_func,
-                      :request_id, :full_insertion, :use_case, :request, :to_compact_metrics_properties_func
+                      :view_id, :insertion, :request_id, :use_case, :request
 
-        attr_accessor :timing, :user_info, :platform_id
+        attr_accessor :timing, :user_info, :platform_id, :insertion
 
         def initialize args = {}
           if args[:id_generator]
@@ -27,11 +26,9 @@ module Promoted
           @device                  = request[:device] || {}
           @view_id                 = request[:view_id]
           @use_case                = Promoted::Ruby::Client::USE_CASES[request[:use_case]] || Promoted::Ruby::Client::USE_CASES['UNKNOWN_USE_CASE']
-          @full_insertion          = args[:full_insertion]
+          @insertion               = request[:insertion] || []
           @user_info               = request[:user_info] || { :user_id => nil, :log_user_id => nil}
-          @timing                  = request[:timing] || { :client_log_timestamp => Time.now.to_i }
-          @to_compact_metrics_properties_func       = args[:to_compact_metrics_properties_func]
-          @to_compact_delivery_properties_func      = args[:to_compact_delivery_properties_func]
+          @timing                  = request[:timing] || { :client_log_timestamp => (Time.now.to_f * 1000).to_i }
 
           # If the user didn't create a client request id, we do it for them.
           request[:client_request_id] = request[:client_request_id] || @id_generator.newID
@@ -68,7 +65,7 @@ module Promoted
             paging: request[:paging],
             client_request_id: client_request_id
           }
-          params[:insertion] = insertions_with_compact_props(@to_compact_delivery_properties_func)
+          params[:insertion] = insertion
 
           params.clean!
         end
@@ -81,7 +78,7 @@ module Promoted
             response_insertions = []
           end
 
-          props = @full_insertion.each_with_object({}) do |insertion, hash|
+          props = @insertion.each_with_object({}) do |insertion, hash|
             if insertion.has_key?(:properties)
               # Don't add nil properties to response insertions.
               hash[insertion[:content_id]] = insertion[:properties]
@@ -100,17 +97,12 @@ module Promoted
           filled_in_copy
         end
 
-        def log_request_params(include_insertions: true, include_request: true)
+        def log_request_params(include_delivery_log:, exec_server:)
           params = {
             user_info: user_info,
             timing: timing,
             client_info: merge_client_info_defaults,
             device: @device,
-            delivery_log: [{
-              execution: {
-                execution_server: Promoted::Ruby::Client::EXECUTION_SERVER['SDK']
-              }
-            }]
           }
 
           if @experiment
@@ -118,81 +110,51 @@ module Promoted
           end
 
           # Log request allows for multiple requests but here we only send one.
-          if include_request
+          if include_delivery_log
             request[:request_id] = request[:request_id] || @id_generator.newID
-            # Set request on delivery log.
-            params[:delivery_log][0][:request] = request
-          end
 
-          if include_insertions
-            # Add a response containing compacted insertions to delivery log.
-            params[:delivery_log][0][:response] = {
-              insertion: compact_metrics_properties
-            }
-            add_missing_ids_on_insertions! request, params[:delivery_log][0][:response][:insertion]
+            params[:delivery_log] = [{
+              execution: {
+                execution_server: exec_server,
+                server_version: Promoted::Ruby::Client::SERVER_VERSION
+              },
+              request: request,
+              response: {
+                insertion: response_insertion
+              }
+            }]
+
+            add_missing_insertion_ids! params[:delivery_log][0][:response][:insertion]            
           end
           
           params.clean!
         end
 
-        def compact_one_insertion(insertion, compact_func)
-          return insertion if (!compact_func || !insertion[:properties])
-
-          # Only need a copy if there are properties to compact.
-          compact_insertion = insertion.dup
-
-          # Let the custom function work with a deep copy of the properties.
-          # There's really no way to work with a shallow copy and still be able
-          # to restore the correct insertion properties after a call to delivery.
-          new_props =  Marshal.load(Marshal.dump(insertion[:properties]))
-          compact_insertion[:properties] = compact_func.call(new_props)
-          compact_insertion.clean!
-          return compact_insertion
-        end
-
-        def insertions_with_compact_props(compact_func)
-          if !compact_func
-            # Nothing to do, avoid copying the whole array.
-            full_insertion
-          else
-            compact_insertions = Array.new(full_insertion.length)
-            full_insertion.each_with_index {|insertion, index|
-              compact_insertions[index] = compact_one_insertion(insertion, compact_func)
-            }
-            compact_insertions
-          end
-        end
-
         def ensure_client_timestamp
           if timing[:client_log_timestamp].nil?
-            timing[:client_log_timestamp] = Time.now.to_i
+            timing[:client_log_timestamp] = (Time.now.to_f * 1000).to_i
           end
         end
 
-        # TODO: This looks overly complicated.
-        def compact_metrics_properties
-          @insertion            = [] # insertion should be set according to the compact insertion
+        def response_insertion
+          @response_insertions  = []
           paging                = request[:paging] || {}
           size                  = paging[:size] ? paging[:size].to_i : 0
           if size <= 0
-            size = full_insertion.length()
+            size = insertion.length()
           end
           offset                = paging[:offset] ? paging[:offset].to_i : 0
 
-          full_insertion.each_with_index do |insertion_obj, index|
+          insertion.each_with_index do |insertion_obj, index|
             # TODO - this does not look performant.
-            break if @insertion.length() >= size
-
-            insertion_obj                = insertion_obj.transform_keys{ |key| key.to_s.to_underscore.to_sym }
-            insertion_obj                = Hash[insertion_obj]
-            insertion_obj[:user_info]    = user_info
-            insertion_obj[:timing]       = timing
-            insertion_obj[:request_id]   = request_id
-            insertion_obj[:position]     = offset + index
-            insertion_obj                = compact_one_insertion(insertion_obj, @to_compact_metrics_properties_func)
-            @insertion << insertion_obj.clean!
-          end
-          @insertion
+            break if @response_insertions.length() >= size
+            response_insertion = Hash[]
+            response_insertion[:content_id]   = insertion_obj[:content_id]
+            response_insertion[:position]     = offset + index
+            response_insertion[:insertion_id] = insertion_obj[:insertion_id]
+            @response_insertions << response_insertion.clean!
+          end
+          @response_insertions
         end
 
         def add_missing_insertion_ids! insertions
@@ -213,21 +175,6 @@ module Promoted
             :traffic_type => Promoted::Ruby::Client::TRAFFIC_TYPE['PRODUCTION']
           })
         end
-        
-        def add_missing_ids_on_insertions! request, insertions
-          insertions.each do |insertion|
-            insertion[:session_id] = request[:session_id] if request[:session_id]
-            insertion[:request_id] = request[:request_id] if request[:request_id]
-          end
-          add_missing_insertion_ids! insertions
-        end
-
-        # A list of the response Insertions.  This client expects lists to be truncated
-        # already to request.paging.size.  If not truncated, this client will truncate
-        # the list.
-        def insertion
-          @insertion
-        end
       end
     end
   end

data/lib/promoted/ruby/client/validator.rb

@@ -99,6 +99,7 @@ module Promoted
                         },
                         {
                             :name => :insertion,
+                            :required => true,
                             :type => Array
                         }
                     ]
@@ -115,6 +116,7 @@ module Promoted
                 end
             end
 
+            # TODO - delete?
             def validate_metrics_request!(metrics_req)
                 validate_fields!(
                     metrics_req,
@@ -123,31 +125,29 @@ module Promoted
                         {
                             :name => :request,
                             :required => true
-                        },
-                        {
-                            :name => :full_insertion,
-                            :required => true,
-                            :type => Array
                         }
                     ]
                 )
 
                 validate_request!(metrics_req[:request])
-                metrics_req[:full_insertion].each {|ins|
-                    validate_insertion! ins
-                }
             end
 
             def check_that_log_ids_not_set! req
+                raise ValidationError.new("Request should be set") if !req[:request]
                 raise ValidationError.new("Request.requestId should not be set") if req.dig(:request, :request_id)
-                raise ValidationError.new("Do not set Request.insertion.  Set full_insertion.") if req[:insertion]
       
-                req[:full_insertion].each do |insertion_hash|
+                req[:request][:insertion].each do |insertion_hash|
                   raise ValidationError.new("Insertion.requestId should not be set") if insertion_hash[:request_id]
                   raise ValidationError.new("'Insertion.insertionId should not be set") if insertion_hash[:insertion_id]
                 end
             end
             
+            def check_that_content_ids_are_set! req
+              req[:request][:insertion].each do |insertion_hash|
+                raise ValidationError.new("Insertion.contentId should be set") if !insertion_hash[:content_id] || insertion_hash[:content_id].empty?
+              end
+            end
+
             private
 
             def validate_fields!(obj, obj_name, fields)

data/lib/promoted/ruby/client/version.rb

@@ -1,7 +1,8 @@
 module Promoted
   module Ruby
     module Client
-      VERSION = "0.1.23"
+      VERSION = "1.0.0"
+      SERVER_VERSION = "rb." + VERSION
     end
   end
 end

data/lib/promoted/ruby/client.rb

@@ -8,6 +8,7 @@ module Promoted
 
       DEFAULT_DELIVERY_TIMEOUT_MILLIS = 250
       DEFAULT_METRICS_TIMEOUT_MILLIS = 3000
+      DEFAULT_MAX_REQUEST_INSERTIONS = 1000
       DEFAULT_DELIVERY_ENDPOINT = "http://delivery.example.com"
       DEFAULT_METRICS_ENDPOINT = "http://metrics.example.com"
 
@@ -20,7 +21,7 @@ module Promoted
 
         attr_reader :perform_checks, :default_only_log, :delivery_timeout_millis, :metrics_timeout_millis, :should_apply_treatment_func,
                     :default_request_headers, :http_client, :logger, :shadow_traffic_delivery_percent, :async_shadow_traffic,
-                    :send_shadow_traffic_for_control
+                    :send_shadow_traffic_for_control, :max_request_insertions
                     
         attr_accessor :request_logging_on, :enabled
         
@@ -30,14 +31,6 @@ module Promoted
           @enabled
         end
 
-        ##            
-        # A common compact properties method implementation.
-        def self.remove_all_properties
-          Proc.new do |properties|
-            nil
-          end
-        end
-
         ##
         # Create and configure a new Promoted client.
         def initialize(params={})
@@ -85,6 +78,8 @@ module Promoted
             @send_shadow_traffic_for_control = params[:send_shadow_traffic_for_control] || false
           end
 
+          @max_request_insertions = params[:max_request_insertions] || DEFAULT_MAX_REQUEST_INSERTIONS
+
           @pool = nil
           if @async_shadow_traffic
             # Thread pool to process delivery of shadow traffic. Will silently drop excess requests beyond the queue
@@ -124,7 +119,7 @@ module Promoted
           # Respect the enabled state
           if !@enabled
             return {
-              insertion: @pager.apply_paging(args[:full_insertion], Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'], args[:request][:paging])
+              insertion: @pager.apply_paging(args[:request][:insertion], Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'], args[:request][:paging])
               # No log request returned when disabled
             }
           end
@@ -132,14 +127,22 @@ module Promoted
           delivery_request_builder = RequestBuilder.new
           delivery_request_builder.set_request_params(args)
 
+          only_log = delivery_request_builder.only_log != nil ? delivery_request_builder.only_log : @default_only_log
+
+          # Gets modified depending on the call.
+          should_send_shadow_traffic = @shadow_traffic_delivery_percent > 0
           # perform_checks raises errors.
           if @perform_checks
             perform_common_checks!(args)
+            if !only_log && args[:insertion_page_type] == Promoted::Ruby::Client::INSERTION_PAGING_TYPE['PRE_PAGED'] then
+                err = DeliveryInsertionPageType.new
+                @logger.error(err) if @logger
+                raise err
+              end
 
-            if args[:insertion_page_type] == Promoted::Ruby::Client::INSERTION_PAGING_TYPE['PRE_PAGED'] then
-              err = DeliveryInsertionPageType.new
-              @logger.error(err) if @logger
-              raise err
+            if should_send_shadow_traffic && args[:insertion_page_type] != Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'] then
+              should_send_shadow_traffic = false
+              @logger.error(ShadowTrafficInsertionPageType.new) if @logger
             end
           end
 
@@ -149,11 +152,16 @@ module Promoted
           cohort_membership_to_log = nil
           insertions_from_delivery = false
 
-          only_log = delivery_request_builder.only_log != nil ? delivery_request_builder.only_log : @default_only_log
           deliver_err = false
 
+          # Trim any request insertions over the maximum allowed.
+          if delivery_request_builder.insertion.length > @max_request_insertions then
+            @logger.warn("Exceeded max request insertions, trimming") if @logger
+            delivery_request_builder.insertion = delivery_request_builder.insertion[0, @max_request_insertions]
+          end
+
           begin
-            @pager.validate_paging(delivery_request_builder.full_insertion, delivery_request_builder.request[:paging])
+            @pager.validate_paging(delivery_request_builder.insertion, delivery_request_builder.request[:paging])
           rescue InvalidPagingError => err
             # Invalid input, log and do SDK-side delivery.
             @logger.warn(err) if @logger
@@ -177,16 +185,22 @@ module Promoted
                 deliver_err = true
                 @logger.error("Error calling delivery: " + err.message) if @logger
               end
-            elsif @send_shadow_traffic_for_control
-              # Call Delivery API to send shadow traffic. This will create the request params with traffic type set.
-              deliver_shadow_traffic args, headers
+              should_send_shadow_traffic = false
+            else
+              should_send_shadow_traffic &&= @send_shadow_traffic_for_control
             end
 
             insertions_from_delivery = (response != nil && !deliver_err);
             response_insertions = delivery_request_builder.fill_details_from_response(
               response && response[:insertion] || [])
           end
-  
+
+          should_send_shadow_traffic &&= should_send_as_shadow_traffic?
+          if should_send_shadow_traffic then
+              # Call Delivery API to send shadow traffic. This will create the request params with traffic type set.
+              deliver_shadow_traffic args, headers
+          end
+
           request_to_log = nil
           if !insertions_from_delivery then
             request_to_log = delivery_request_builder.request
@@ -194,11 +208,13 @@ module Promoted
           end
 
           log_req = nil
+          exec_server = (insertions_from_delivery ? Promoted::Ruby::Client::EXECUTION_SERVER['API'] : Promoted::Ruby::Client::EXECUTION_SERVER['SDK'])
+          
           # We only return a log request if there's a request or cohort to log.
           if request_to_log || cohort_membership_to_log
             log_request_builder = RequestBuilder.new
             log_request = {
-              :full_insertion => response_insertions,
+              :insertion => response_insertions,
               :experiment => cohort_membership_to_log,
               :request => request_to_log
             }
@@ -212,55 +228,19 @@ module Promoted
             # On a successful delivery request, we don't log the insertions
             # or the request since they are logged on the server-side.
             log_req = log_request_builder.log_request_params(
-              include_insertions: !insertions_from_delivery, 
-              include_request: !insertions_from_delivery)
+              include_delivery_log: !insertions_from_delivery, 
+              exec_server: exec_server)
           end
 
           client_response = {
             insertion: response_insertions,
             log_request: log_req,
-            execution_server: insertions_from_delivery ? Promoted::Ruby::Client::EXECUTION_SERVER['API'] : Promoted::Ruby::Client::EXECUTION_SERVER['SDK'],
+            execution_server: exec_server,
             client_request_id: delivery_request_builder.client_request_id
           }
           return client_response
         end
 
-        ##
-        # Generate a log request for a subsequent call to send_log_request
-        # or for logging via alternative means.
-        def prepare_for_logging args, headers={}
-          args = Promoted::Ruby::Client::Util.translate_hash(args)
-
-          if !@enabled
-            return {
-              insertion: args[:full_insertion]
-            }
-          end
-
-          log_request_builder = RequestBuilder.new
-
-          # Note: This method expects as JSON (string keys) but internally, RequestBuilder
-          # transforms and works with symbol keys.
-          log_request_builder.set_request_params(args)
-          shadow_traffic_err = false
-          if @perform_checks
-            perform_common_checks! args
-
-            if @shadow_traffic_delivery_percent > 0 && args[:insertion_page_type] != Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'] then
-              shadow_traffic_err = true
-              @logger.error(ShadowTrafficInsertionPageType.new) if @logger
-            end
-          end
-          
-          log_request_builder.ensure_client_timestamp
-
-          if !shadow_traffic_err && should_send_as_shadow_traffic?
-            deliver_shadow_traffic args, headers
-          end
-
-          log_request_builder.log_request_params
-        end
-
         ##
         # Sends a log request (previously created by a call to prepare_for_logging) to the metrics endpoint.
         def send_log_request log_request_params, headers={}
@@ -277,7 +257,7 @@ module Promoted
         ##
         # Creates response insertions for SDK-side delivery, when we don't get response insertions from Delivery API.
         def build_sdk_response_insertions delivery_request_builder
-          response_insertions = @pager.apply_paging(delivery_request_builder.full_insertion, Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'], delivery_request_builder.request[:paging])
+          response_insertions = @pager.apply_paging(delivery_request_builder.insertion, Promoted::Ruby::Client::INSERTION_PAGING_TYPE['UNPAGED'], delivery_request_builder.request[:paging])
           delivery_request_builder.add_missing_insertion_ids! response_insertions
           return response_insertions
         end
@@ -354,7 +334,7 @@ module Promoted
           delivery_request_params[:client_info][:traffic_type] = Promoted::Ruby::Client::TRAFFIC_TYPE['SHADOW']
 
           begin
-            @pager.validate_paging(delivery_request_builder.full_insertion, delivery_request_builder.request[:paging])
+            @pager.validate_paging(delivery_request_builder.insertion, delivery_request_builder.request[:paging])
           rescue InvalidPagingError => err
             # Invalid input, log and skip.
             @logger.warn("Shadow traffic call failed with invalid paging #{err}") if @logger
@@ -382,6 +362,7 @@ module Promoted
           begin
             @validator.check_that_log_ids_not_set!(req)
             @validator.validate_metrics_request!(req)
+            @validator.check_that_content_ids_are_set!(req)
           rescue StandardError => err
             @logger.error(err) if @logger
             raise

data/promoted-ruby-client.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/promotedai/promoted-ruby-client'
   spec.license       = 'MIT'
 
-  spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+  # spec.metadata["allowed_push_host"] = "http://rubygems.org/gems/promoted-ruby-client"
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/promotedai/promoted-ruby-client"
   spec.metadata["changelog_uri"] = "https://github.com/promotedai/promoted-ruby-client/blob/master/CHANGELOG.md"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promoted-ruby-client
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 1.0.0
 platform: ruby
 authors:
 - scottmcmaster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-15 00:00:00.000000000 Z
+date: 2023-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -150,7 +150,6 @@ homepage: https://github.com/promotedai/promoted-ruby-client
 licenses:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org/
   homepage_uri: https://github.com/promotedai/promoted-ruby-client
   source_code_uri: https://github.com/promotedai/promoted-ruby-client
   changelog_uri: https://github.com/promotedai/promoted-ruby-client/blob/master/CHANGELOG.md