leanplum_api 3.1.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2908e4c232266ec051f099699765d0605a270e2b
-  data.tar.gz: 82b980405f5c55a3096e4101cb2c7b503796f18b
+  metadata.gz: ba21ebe73260c66ae36b3c901abfe6824d238b26
+  data.tar.gz: '009e58d6f0537a717bd1a66ddf6f39d5601ab328'
 SHA512:
-  metadata.gz: 21525c8ab65ad7b2226b06bb3717df28b131aba26e114625b20aa32c6f5b4e828655f3d485b3d85f5f80d7dda6165d9f8926f533109cdf03e065cd38a0b67ae2
-  data.tar.gz: 07f5ebb8514bedcd977f74d173127b074fb2dae7efd36bcc0fc91181e8d2865647ca96dbb8e61cf32b3836fd94b259da2b0ee7e4e2447d523c91b8d593d331ec
+  metadata.gz: 0e56f3fea79360b0820803e7edb1d153f19691d7adf644699feba9c7abe00edd58593852c8e62988dd202f3471ad7818ed8de9c55225adf6fb10b657c4e420c5
+  data.tar.gz: 9404b64c448032f32cde14db3082cdb4fc5fa4e2b4d7e27de1ede0ea5f4dc653fd4a8bdf8d3c01b9983df5a75687deb62c922c6d4d6fae05b2035f3f518e88ae

data/README.md

@@ -8,11 +8,11 @@ Leanplum calls it a REST API but it is not very RESTful.
 
 Leanplum also likes to change and break stuff in their API without changing the version number, so buyer beware.
 
-The gem uses the ```multi``` method with a POST for all event tracking and user attribute updating requests.  Check Leanplum's docs for more information on ```multi```.
+The gem uses the `multi` method with a POST for all event tracking and user attribute updating requests.  Check Leanplum's docs for more information on `multi`.
 
 Tested with Leanplum API version 1.0.6 - which is actually totally meaningless because the version is always 1.0.6, even when they make major revisions to how the API works.
 
-`required_ruby_version` is set to 1.9 but this code has only been tested with Ruby 2.1.5 and up!
+`required_ruby_version` is set to 2.0 but this code has only been tested with Ruby 2.1.5 and up!
 
 ## Configuration
 
@@ -44,6 +44,9 @@ LeanplumApi.configure do |config|
   # Set this to true to send events and user attributes to the test environment.
   # Defaults to false.  See "Debugging" below for more info.
   config.developer_mode = true
+
+  # Override validations for Leanplum responses. True by default and you should probably leave it that way.
+  config.validate_response = true
 end
 ```
 
@@ -54,9 +57,16 @@ end
 ```ruby
 api = LeanplumApi::API.new
 
+# Setting device attributes requires a device_id.
+device_attributes = {
+  device_id: 'big_boss_belt_buckler',
+  device_model: 'four_vogues'
+}
+api.set_device_attributes(device_attributes)
+
 # You must provide either :user_id or :device_id for requests involving
 # attribute updates or event tracking.
-attribute_hash = {
+user_attributes = {
   user_id: 12345,
   first_name: 'Mike',
   last_name: 'Jones',
@@ -64,23 +74,26 @@ attribute_hash = {
   email: 'still_tippin@test.com',
   birthday: Date.today  # Dates/times will be converted to ISO8601 format
 }
-api.set_user_attributes(attribute_hash)
-
-# In 2017, Leanplum implemented the ability to set various first and last timestamps for event occurrences, as well as
-# counts for that event in their API at the same time as you set various attributes for that user.
-# This is what it would look like to push data about an event that happened 5 times between 2015-02-01 and today.
-attribute_hash = {
+api.set_user_attributes(user_attributes)
+
+# In 2017, Leanplum implemented the ability to set various first and last timestamps for event
+# occurrences, as well as counts for that event in their setUserAttributes API.
+# They also added the ability to set devices for that user.
+# This is what it would look like to push data about an event that happened 5 times between
+# 2015-02-01 and today along with a set of devices for that user.
+user_attributes = {
   user_id: 12345,
+  devices: [device_attributes],
   events: {
     my_event_name: {
       count: 5,
       value: 'woodgrain',
-      firstTime: '2015-02-01'.to_time,
-      lastTime: Time.now.utc
+      firstTime: '2015-02-01'.to_time, # Dates/times will be converted to epoch seconds
+      lastTime: Time.now.utc           # Dates/times will be converted to epoch seconds
     }
   }
 }
-api.set_user_attributes(attribute_hash)
+api.set_user_attributes(user_attributes)
 
 # You must also provide the :event property for event tracking.
 ## :info is an optional property for an extra string.
@@ -89,63 +102,79 @@ api.set_user_attributes(attribute_hash)
 event = {
   user_id: 12345,
   event: 'purchase',
+  time: Time.now.utc, # Event timestamps will be converted to epoch seconds
   info: 'reallybigpurchase',
-  time: Time.now.utc, # Event timestamps will be converted to epoch seconds by the gem.
   some_event_property: 'boss_hog_on_candy'
 }
 api.track_events(event)
 # Events tracked like that will be made part of a session; for independent events use :allow_offline
-#   Ed. note 2017-09-12 - looks like Leanplum changed their API and everything is considered offline now
+#   Ed. note 2017-09-12 - looks like Leanplum changed their API and everything is considered offline now.
 api.track_events(event, allow_offline: true)
 
-# You can also track events and user attributes at the same time
-api.track_multi(event, attribute_hash)
+# You can also track events, user attributes, and device attributes at the same time. Magic!
+api.track_multi(
+  events: event,
+  user_attributes: user_attributes,
+  device_attributes: device_attributes,
+  options: { force_anomalous_override: true }
+)
 
 # If your event is sufficiently far in the past, leanplum will mark your user as "Anomalous"
-# To force a reset of this flag, either call the method directly
+# To force a reset of this flag, either call the method directly.
 api.reset_anomalous_users([12345, 23456])
-# Or use the :force_anomalous_override option when calling track_events or track_multi
+# Or use the :force_anomalous_override option when calling track_events or track_multi.
 api.track_events(event, force_anomalous_override: true)
 ```
 
 ### API based data export:
 
 ```ruby
-api = LeanplumApi::API.new
-job_id = api.export_data(start_time, end_time)
-response = wait_for_export_job(job_id)
+data_export_api = LeanplumApi::DataExportAPI.new
+
+# Bulk data export
+job_id = data_export_api.export_data(start_time, end_time)
+response = data_export_api.wait_for_export_job(job_id)
+
+# User export
+job_id = data_export_api.export_users(ab_test_id, segment)
+response = data_export_api.wait_for_export_job(job_id)
 ```
 
 **Note well that Leanplum now officially recommends use of the automated S3 export instead of API based export.**  According to a Leanplum engineer these two data export methodologies are completely independent data paths and in our experience we have found API based data export to be missing 10-15% of the data that is eventually returned by the automated export.
 
 ### Other Available Methods
-* `api.user_attributes(user_id)`
-* `api.user_events(user_id)`
+These are mostly simple wrappers around Leanplum's API methods.  See their documentation for details.
+
+* `api.export_user(user_id)`
+* `api.user_attributes(user_id)` (gives you the attributes section of `exportUser`)
+* `api.user_events(user_id)` (gives you the events section of `exportUser`)
 * `api.get_ab_tests(only_recent)`
 * `api.get_ab_test(ab_test_id)`
 * `api.get_messages(only_recent)`
 * `api.get_message(message_id)`
 * `api.get_variant(variant_id)`
 * `api.get_vars(user_id)`
+* `api.delete_user(user_id)`
+
 
 ## Specs
 
 `bundle exec rspec` should work fine at running existing specs.
 
-To write _new_ specs (or regenerate one of [VCR](https://github.com/vcr/vcr)'s YAML files), you must set the `LEANPLUM_PRODUCTION_KEY`, `LEANPLUM_APP_ID`, `LEANPLUM_CONTENT_READ_ONLY_KEY`, `LEANPLUM_DEVELOPMENT_KEY`, and `LEANPLUM_DATA_EXPORT_KEY` environment variables (preferably to some development only keys) to something and then run rspec.  VCR will create fixture data based on your requests, masking your actual keys so that it's safe to commit the file.
-
-> BE AWARE THAT IF YOU WRITE A NEW SPEC OR DELETE A VCR FILE, IT'S POSSIBLE THAT REAL DATA WILL BE WRITTEN TO THE `LEANPLUM_APP_ID` YOU CONFIGURE!  Certainly a real request will be made to rebuild the VCR file, and while specs run with ```devMode=true```, it's usually a good idea to create a fake app for testing/running specs against.
+To write _new_ specs (or regenerate one of [VCR](https://github.com/vcr/vcr)'s YAML files), you must set the `LEANPLUM_PRODUCTION_KEY`, `LEANPLUM_APP_ID`, `LEANPLUM_CONTENT_READ_ONLY_KEY`, `LEANPLUM_DEVELOPMENT_KEY`, and `LEANPLUM_DATA_EXPORT_KEY` environment variables (preferably to some development only keys).  The easiest way to do this is to create a `.env` file based on the [.env.example](.env.example) file in the repo and then fill in the blanks; the `dotenv` gem will handle loading them into the environment when you run `bundle exec rspec`.
 
 ```bash
-export LEANPLUM_APP_ID=app_somethingsomething2039410238
-export LEANPLUM_PRODUCTION_KEY=dev_somethingsomeg123456
-export LEANPLUM_DATA_EXPORT_KEY=data_something_3238mmmX
-export LEANPLUM_CONTENT_READ_ONLY_KEY=sometingsome23xx9
-export LEANPLUM_DEVELOPMENT_KEY=sometingsome23xx923n23i
-
+cp .env.example .env
+vi .env # open in your favorite text editor; edit it and fill in the various keys
 bundle exec rspec
 ```
 
+> BE AWARE THAT IF YOU WRITE A NEW SPEC OR DELETE A VCR FILE, IT'S POSSIBLE THAT REAL DATA WILL BE WRITTEN TO THE `LEANPLUM_APP_ID` YOU CONFIGURE!  Certainly a real request will be made to rebuild the VCR file, and while specs run with ```devMode=true```, it's usually a good idea to create a fake app for testing/running specs against.
+
+VCR will create fixture data based on your requests, masking your actual keys so that it's safe to commit the file.
+
+One gotcha is that the `Timecop` gem is used to freeze the specs at a particular point in time.  You may need to update the `Timecop` config in [spec_helper.rb](spec/spec_helper.rb) and regenerate all the fixtures should you want to record any new interactions.  If you see warnings about "Device skew" in the fixtures, this is how you fix it.
+
 ## Debugging
 
 The `LEANPLUM_API_DEBUG` environment variable will trigger full printouts of Faraday's debug output to STDERR and to the configured logger.
@@ -164,6 +193,8 @@ LeanplumApi.configure do |config|
 end
 ```
 
+This also works when running specs.
+
 ### Developer Mode
 
 You can also configure "developer mode".  This will use the `devMode=true` parameter on some requests, which seems to sends them to a separate queue which might not count towards Leanplum's usage billing.

data/lib/leanplum_api/api.rb

@@ -1,146 +1,51 @@
 module LeanplumApi
   class API
-    extend Gem::Deprecate
+    # API Command Constants
+    SET_USER_ATTRIBUTES = 'setUserAttributes'.freeze
+    SET_DEVICE_ATTRIBUTES = 'setDeviceAttributes'.freeze
+    TRACK = 'track'.freeze
 
-    class LeanplumValidationException < RuntimeError; end
+    # Data export related constants
+    EXPORT_PENDING = 'PENDING'.freeze
+    EXPORT_RUNNING = 'RUNNING'.freeze
+    EXPORT_FINISHED = 'FINISHED'.freeze
 
-    EXPORT_PENDING = 'PENDING'
-    EXPORT_RUNNING = 'RUNNING'
-    EXPORT_FINISHED = 'FINISHED'
-
-    def initialize(options = {})
+    def initialize
       fail 'LeanplumApi not configured yet!' unless LeanplumApi.configuration
     end
 
     def set_user_attributes(user_attributes, options = {})
-      track_multi(nil, user_attributes, options)
+      track_multi(user_attributes: user_attributes, options: options)
     end
 
-    def track_events(events, options = {})
-      track_multi(events, nil, options)
-    end
-
-    # This method is for tracking events and/or updating user attributes at the same time, batched together like
-    # leanplum recommends.
-    # Set force_anomalous_override: true to catch warnings from leanplum about anomalous events and force them to not
-    # be considered anomalous
-    def track_multi(events = nil, user_attributes = nil, options = {})
-      request_data = Array.wrap(user_attributes).map { |h| build_user_attributes_hash(h) } +
-                     Array.wrap(events).map { |h| build_event_attributes_hash(h, options) }
-      response = production_connection.multi(request_data).body['response']
-
-      if options[:force_anomalous_override]
-        user_ids_to_reset = []
-        response.each_with_index do |indicator, i|
-          # Leanplum's engineering team likes to break their API and or change stuff without warning (often)
-          # and has no idea what "versioning" actually means, so we just reset everyone all the time.
-          # This condition should be:
-          # if indicator['warning'] && indicator['warning']['message'] =~ /Past event detected/i
-          #
-          # but it has to be:
-          if indicator['warning']
-            # Leanplum does not return their warnings in order!!!  So we just have
-            # to reset everyone who had any events.  This is what the code should be:
-            # user_ids_to_reset << request_data[i]['userId']
-
-            # This is what it has to be:
-            user_ids_to_reset = events.map { |e| e[:user_id] }.uniq
-          end
-        end
-
-        unless user_ids_to_reset.empty?
-          LeanplumApi.configuration.logger.debug("Resetting anomalous user ids: #{user_ids_to_reset}")
-          reset_anomalous_users(user_ids_to_reset)
-        end
-      end
+    def set_device_attributes(device_attributes, options = {})
+      track_multi(device_attributes: device_attributes, options: options)
     end
 
-    # Returns the jobId
-    # Leanplum has confirmed that using startTime and endTime, especially trying to be relatively up to the minute,
-    # leads to sort of unprocessed information that can be incomplete.
-    # They recommend using the automatic export to S3 if possible.
-    def export_data(start_time, end_time = nil)
-      LeanplumApi.configuration.logger.warn("You should probably use the direct S3 export instead of exportData")
-      fail "Start time #{start_time} after end time #{end_time}" if end_time && start_time > end_time
-      LeanplumApi.configuration.logger.info("Requesting data export from #{start_time} to #{end_time}...")
-
-      # Because of open questions about how startTime and endTime work (or don't work, as the case may be), we
-      # only want to pass the dates unless start and end times are specifically requested.
-      params = { action: 'exportData', startDate: start_time.strftime('%Y%m%d') }
-      params[:startTime] = start_time.strftime('%s') if start_time.is_a?(DateTime) || start_time.is_a?(Time)
-      if end_time
-        params[:endDate] = end_time.strftime('%Y%m%d')
-        params[:endTime] = end_time.strftime('%s') if end_time.is_a?(DateTime) || end_time.is_a?(Time)
-      end
-
-      # Handle optional S3 export params
-      if LeanplumApi.configuration.s3_bucket_name
-        fail 's3_bucket_name set but s3_access_id not configured!' unless LeanplumApi.configuration.s3_access_id
-        fail 's3_bucket_name set but s3_access_key not configured!' unless LeanplumApi.configuration.s3_access_key
-
-        params.merge!(
-          s3BucketName: LeanplumApi.configuration.s3_bucket_name,
-          s3AccessId: LeanplumApi.configuration.s3_access_id,
-          s3AccessKey: LeanplumApi.configuration.s3_access_key
-        )
-        params.merge!(s3ObjectPrefix: LeanplumApi.configuration.s3_object_prefix) if LeanplumApi.configuration.s3_object_prefix
-      end
-
-      data_export_connection.get(params).body['response'].first['jobId']
+    def track_events(events, options = {})
+      track_multi(events: events, options: options)
     end
 
-    # See leanplum docs.
-    # The segment syntax is identical to that produced by the "Insert Value" feature on the dashboard.
-    # Examples: 'Country = "US"', '{Country = "US"} and {App version = 1}'.
-    def export_users(segment, ab_test_id)
-      data_export_connection.get(action: 'exportUsers', segment: segment, ab_test_id: ab_test_id)
-    end
+    # This method is for tracking events and/or updating user and/or device attributes
+    # at the same time, batched together like leanplum recommends.
+    # Set the :force_anomalous_override option to catch warnings from leanplum
+    # about anomalous events and force them to not be considered anomalous.
+    def track_multi(events: nil, user_attributes: nil, device_attributes: nil, options: {})
+      events = Array.wrap(events)
 
-    def get_export_results(job_id)
-      response = data_export_connection.get(action: 'getExportResults', jobId: job_id).body['response'].first
-
-      if response['state'] == EXPORT_FINISHED
-        LeanplumApi.configuration.logger.info("Export finished.")
-        LeanplumApi.configuration.logger.debug("  Response: #{response}")
-        {
-          files: response['files'],
-          number_of_sessions: response['numSessions'],
-          number_of_bytes: response['numBytes'],
-          state: response['state'],
-          s3_copy_status: response['s3CopyStatus']
-        }
-      else
-        { state: response['state'] }
-      end
-    end
+      request_data = events.map { |h| build_event_attributes_hash(h.dup, options) } +
+                     Array.wrap(user_attributes).map { |h| build_user_attributes_hash(h.dup) } +
+                     Array.wrap(device_attributes).map { |h| build_device_attributes_hash(h.dup) }
 
-    def wait_for_export_job(job_id, polling_interval = 60)
-      while get_export_results(job_id)[:state] != EXPORT_FINISHED
-        LeanplumApi.configuration.logger.debug("Polling job #{job_id}: #{get_export_results(job_id)}")
-        sleep(polling_interval)
-      end
-      get_export_results(job_id)
-    end
+      response = production_connection.multi(request_data)
+      force_anomalous_override(response, events) if options[:force_anomalous_override]
 
-    # Remove in version 4.x
-    def wait_for_job(job_id, polling_interval = 60)
-      wait_for_export_job(job_id, polling_interval)
+      response
     end
-    deprecate :wait_for_job, 'wait_for_export_job', 2018, 6
 
     def user_attributes(user_id)
-      export_user(user_id)['userAttributes'].inject({}) do |attrs, (k, v)|
-        # Leanplum doesn't use true JSON for booleans...
-        if v == 'True'
-          attrs[k] = true
-        elsif v == 'False'
-          attrs[k] = false
-        else
-          attrs[k] = v
-        end
-
-        attrs
-      end
+      # Leanplum returns strings instead of booleans
+      Hash[export_user(user_id)['userAttributes'].map { |k, v| [k, v.to_s =~ /\Atrue|false\z/i ? eval(v.downcase) : v] }]
     end
 
     def user_events(user_id)
@@ -148,102 +53,114 @@ module LeanplumApi
     end
 
     def export_user(user_id)
-      data_export_connection.get(action: 'exportUser', userId: user_id).body['response'].first
+      response = data_export_connection.get(action: 'exportUser', userId: user_id).first
+      fail ResourceNotFoundError, "User #{user_id} not found" unless response['events'] || response['userAttributes']
+      response
     end
 
     def get_ab_tests(only_recent = false)
-      content_read_only_connection.get(action: 'getAbTests', recent: only_recent).body['response'].first['abTests']
+      content_read_only_connection.get(action: 'getAbTests', recent: only_recent).first['abTests']
     end
 
     def get_ab_test(ab_test_id)
-      content_read_only_connection.get(action: 'getAbTest', id: ab_test_id).body['response'].first['abTest']
+      content_read_only_connection.get(action: 'getAbTest', id: ab_test_id).first['abTest']
     end
 
     def get_variant(variant_id)
-      content_read_only_connection.get(action: 'getVariant', id: variant_id).body['response'].first['variant']
+      content_read_only_connection.get(action: 'getVariant', id: variant_id).first['variant']
     end
 
     def get_messages(only_recent = false)
-      content_read_only_connection.get(action: 'getMessages', recent: only_recent).body['response'].first['messages']
+      content_read_only_connection.get(action: 'getMessages', recent: only_recent).first['messages']
     end
 
     def get_message(message_id)
-      content_read_only_connection.get(action: 'getMessage', id: message_id).body['response'].first['message']
+      content_read_only_connection.get(action: 'getMessage', id: message_id).first['message']
     end
 
     def get_vars(user_id)
-      production_connection.get(action: 'getVars', userId: user_id).body['response'].first['vars']
+      production_connection.get(action: 'getVars', userId: user_id).first['vars']
+    end
+
+    def delete_user(user_id)
+      development_connection.get(action: 'deleteUser', userId: user_id).first['vars']
     end
 
-    # If you pass old events OR users with old date attributes (i.e. create_date for an old users), leanplum will mark
-    # them 'anomalous' and exclude them from your data set.
-    # Calling this method after you pass old events will fix that for all events for the specified user_id
-    # For some reason this API feature requires the developer key
+    # If you pass old events OR users with old date attributes (e.g. create_date for an old user), Leanplum
+    # wil mark them 'anomalous' and exclude them from your data set.
+    # Calling this method after you pass old events will fix that for all events for the specified user_id.
     def reset_anomalous_users(user_ids)
       user_ids = Array.wrap(user_ids)
-      request_data = user_ids.map { |user_id| { action: 'setUserAttributes', resetAnomalies: true, userId: user_id } }
+      request_data = user_ids.map { |user_id| { action: SET_USER_ATTRIBUTES, resetAnomalies: true, userId: user_id } }
       development_connection.multi(request_data)
     end
 
     private
 
     def production_connection
-      fail "production_key not configured!" unless LeanplumApi.configuration.production_key
+      fail 'production_key not configured!' unless LeanplumApi.configuration.production_key
       @production ||= Connection.new(LeanplumApi.configuration.production_key)
     end
 
     # Only instantiated for data export endpoint calls
     def data_export_connection
-      fail "data_export_key not configured!" unless LeanplumApi.configuration.data_export_key
+      fail 'data_export_key not configured!' unless LeanplumApi.configuration.data_export_key
       @data_export ||= Connection.new(LeanplumApi.configuration.data_export_key)
     end
 
     # Only instantiated for ContentReadOnly calls (AB tests)
     def content_read_only_connection
-      fail "content_read_only_key not configured!" unless LeanplumApi.configuration.content_read_only_key
+      fail 'content_read_only_key not configured!' unless LeanplumApi.configuration.content_read_only_key
       @content_read_only ||= Connection.new(LeanplumApi.configuration.content_read_only_key)
     end
 
     def development_connection
-      fail "development_key not configured!" unless LeanplumApi.configuration.development_key
+      fail 'development_key not configured!' unless LeanplumApi.configuration.development_key
       @development ||= Connection.new(LeanplumApi.configuration.development_key)
     end
 
     # Deletes the user_id and device_id key/value pairs from the hash parameter.
     def extract_user_id_or_device_id_hash!(hash)
-      user_id = hash.delete(:user_id)
-      device_id = hash.delete(:device_id)
+      user_id = hash.delete(:user_id) || hash.delete(:userId)
+      device_id = hash.delete(:device_id) || hash.delete(:deviceId)
       fail "No device_id or user_id in hash #{hash}" unless user_id || device_id
 
       user_id ? { userId: user_id } : { deviceId: device_id }
     end
 
-    # Action can be any command that takes a userAttributes param.  "start" (a session) is the other command that most
-    # obviously takes userAttributes.
-    # As of 2015-10 Leanplum supports ISO8601 date & time strings as user attributes.
-    def build_user_attributes_hash(user_hash, action = 'setUserAttributes')
-      user_hash = HashWithIndifferentAccess.new(user_hash)
-      user_hash.each { |k, v| user_hash[k] = v.iso8601 if is_date_or_time?(v) }
+    # build a user attributes hash
+    # @param [Hash] user_hash user attributes to set into LP user
+    def build_user_attributes_hash(user_hash)
+      user_attr_hash = extract_user_id_or_device_id_hash!(user_hash)
+      user_attr_hash[:action] = SET_USER_ATTRIBUTES
+      user_attr_hash[:devices] = user_hash.delete(:devices) if user_hash.key?(:devices)
 
-      if (events = user_hash.delete(:events))
-        events.each do |event_name, event_props|
-          event_props.each { |k, v| event_props[k] = v.strftime('%s').to_i if is_date_or_time?(v) }
-        end
+      if user_hash.key?(:events)
+        user_attr_hash[:events] = user_hash.delete(:events)
+        user_attr_hash[:events].each { |k, v| user_attr_hash[:events][k] = fix_seconds_since_epoch(v) }
       end
 
-      user_attributes = extract_user_id_or_device_id_hash!(user_hash).merge(action: action, userAttributes: user_hash)
-      user_attributes[:events] = events if events
-      user_attributes
+      user_attr_hash[:userAttributes] = fix_iso8601(user_hash)
+      user_attr_hash
+    end
+
+    # build a user attributes hash
+    # @param [Hash] device_hash device attributes to set into LP device
+    def build_device_attributes_hash(device_hash)
+      device_hash = fix_iso8601(device_hash)
+      extract_user_id_or_device_id_hash!(device_hash).merge(
+        action: SET_DEVICE_ATTRIBUTES,
+        deviceAttributes: device_hash
+      )
     end
 
     # Events have a :user_id or :device id, a name (:event) and an optional time (:time)
     # Use the :allow_offline option to send events without creating a new session
     def build_event_attributes_hash(event_hash, options = {})
-      event_hash = HashWithIndifferentAccess.new(event_hash)
       event_name = event_hash.delete(:event)
       fail ":event key not present in #{event_hash}" unless event_name
 
-      event = { action: 'track', event: event_name }.merge(extract_user_id_or_device_id_hash!(event_hash))
+      event = { action: TRACK, event: event_name }.merge(extract_user_id_or_device_id_hash!(event_hash))
       event.merge!(time: event_hash.delete(:time).strftime('%s').to_i) if event_hash[:time]
       event.merge!(info: event_hash.delete(:info)) if event_hash[:info]
       event.merge!(allowOffline: true) if options[:allow_offline]
@@ -251,6 +168,40 @@ module LeanplumApi
       event_hash.keys.size > 0 ? event.merge(params: event_hash.symbolize_keys ) : event
     end
 
+    # Leanplum's engineering team likes to break their API and or change stuff without warning (often)
+    # and has no idea what "versioning" actually means, so we just reset everyone on any type of warning.
+    def force_anomalous_override(responses, events)
+      user_ids_to_reset = []
+
+      responses.each_with_index do |indicator, i|
+        # This condition should be:
+        # if indicator['warning'] && indicator['warning']['message'] =~ /Past event detected/i
+        # but it has to be:
+        if indicator['warning']
+          # Leanplum does not return their warnings in order!!!  So we just have
+          # to reset everyone who had any events.  This is what the code should be:
+          # user_ids_to_reset << request_data[i]['userId']
+
+          # This is what it has to be:
+          user_ids_to_reset = events.map { |e| e[:user_id] }.uniq
+        end
+      end
+
+      unless user_ids_to_reset.empty?
+        LeanplumApi.configuration.logger.debug("Resetting anomalous user ids: #{user_ids_to_reset}")
+        reset_anomalous_users(user_ids_to_reset)
+      end
+    end
+
+    # As of 2015-10 Leanplum supports ISO8601 date & time strings as user attributes.
+    def fix_iso8601(attr_hash)
+      Hash[attr_hash.map { |k, v| [k, (is_date_or_time?(v) ? v.iso8601 : v)] }]
+    end
+
+    def fix_seconds_since_epoch(attr_hash)
+      Hash[attr_hash.map { |k, v| [k, (is_date_or_time?(v) ? v.strftime('%s').to_i : v)] }]
+    end
+
     def is_date_or_time?(obj)
       obj.is_a?(Date) || obj.is_a?(Time) || obj.is_a?(DateTime)
     end