customerio 2.2.1 → 4.0.1

checksums.yaml

@@ -1,17 +1,7 @@
 ---
-!binary "U0hBMjU2":
-  metadata.gz: !binary |-
-    NGJmMGRlMjNmNzZmNzFiZDI5NjM4YzRhNTczOWY1MzUzY2Y1MzVhMmMwZDg3
-    YTcyNTM4NDY5MjM4OTBiOTNlOA==
-  data.tar.gz: !binary |-
-    NDE5YWFjYmM4NjQxYWU2YThhZDNhYzM0ZDdmOTU2OWExNWZmODM4YjEwY2Ri
-    ZTZlOWIzNzU5ZDUyZmY4ZDg5Yg==
+SHA256:
+  metadata.gz: fbff37c21ea57a934d671356e89ef06114170d0b753c91048c255b399ce146de
+  data.tar.gz: 1d225801d24005870b63aa2f95850b47cef6ef822f7f3132ea9b7378cffaa852
 SHA512:
-  metadata.gz: !binary |-
-    MDkxMTRkNGZjYWQyYjIzZjEwODM2YzQxN2Y4YzVmZmZiOWE5YmU3NjUwYzdi
-    Zjg5NzE2ZDg1YWI0YTg2MDY5NTkzM2QwOWNlNTAwN2U3MThmODMwODU5YTVi
-    YzA1ZmM2OTFmYzVkNWIxMjhhMGViNjhhODQ1ZWJkODIxODlhODg=
-  data.tar.gz: !binary |-
-    YjNiNTRlZTNkMjg2NGEwNjNiZmEyMTQyZWZhNTMyYjgxZDI1MDkxOGM4MDI1
-    NjRlY2U4OTBmMTM0ZTM1ZDU5M2FkNjJjNjE2ZjhmZTRiMzE0ZmE1MWJkMTQx
-    NDE1MDNhMWYzYmFmZTBlMTJlZDU5OGQzOGQwYjM5ZWNkMGZhOTU=
+  metadata.gz: c41f22bc7fe6038432cd9e854c5bd18cd4b117f2320d02c3e142f5256cf0626de05e982db9676fdc3feed48cd26a6343e10717c196ab0e22b7d3798d4b5bb444
+  data.tar.gz: f70520dda7f7defab832cc4efc85771c10e3e042aff034512a261b630f73db2f63474b8103dbf43e4e98be29a0e03a20b0993f1a9e31871f84e2fad41d6d0f8c

data/.github/workflows/main.yml

@@ -0,0 +1,30 @@
+name: ruby_ci
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        ruby: ['2.5', '2.6', '2.7']
+    runs-on: ubuntu-latest 
+    steps:
+    - uses: actions/checkout@v2
+    - name: set up ruby
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: install bundle
+      run: |
+         sudo apt-get -yqq install libpq-dev
+         gem install bundler
+    - name: Cache dependencies
+      uses: actions/cache@v2
+      with:
+        path: vendor/bundle
+        key: customerio-${{ matrix.ruby }}-${{ hashFiles('customerio.gemspec') }}
+        restore-keys: |
+          customerio-${{ matrix.ruby }}-
+    - name: Install dependencies
+      run: bundle install --path vendor/bundle
+    - run: bundle exec rspec

data/CHANGELOG.markdown

@@ -1,3 +1,51 @@
+## Customerio 4.0.1 - July 13, 2021
+### Changed
+- Update addressable gem dependency to v2.8.0
+
+## Customerio 4.0.0 - July 6, 2021
+### Removed
+- The `anonymous_track` method.
+
+### Added
+- The `track_anonymous` method replaces `anonymous_track`. This method requires an `anonymous_id` parameter and will no longer trigger campaigns. If you previously used anonymous events to trigger campaigns, you can still do so [directly through the API](https://customer.io/docs/api/#operation/trackAnonymous). We now refer to anonymous events that trigger campaigns as ["invite events"](https://customer.io/docs/anonymous-events/#anonymous-or-invite). 
+
+## Customerio 3.1.0 - March 25, 2021
+### Added
+- Support for EU region
+
+### Removed
+### Changed
+- `Customerio::Client` and `CustomerIO::APIClient`  have a new parameter `region` that can be set to either `Customerio::Regions::EU` or `Customerio::Regions::US` (defaults to `Customerio::Regions::US`)
+
+## Customerio 3.0.0 - Dec 2, 2020
+
+### Added
+- Support for the Transactional API
+
+### Removed
+- `add_to_segment` and `remove_from_segment` methods
+- Support for non-JSON data
+
+### Changed
+- IDs in the URLs are now escaped.
+- Improved validations for data that's passed in.
+- Earlier, if you passed in an event name without a customer ID to the `track` method, we would create an anonymous event. That is now removed. To create an anonymous event, use the `anonymous_track` method.
+
+
+## Customerio 3.0.0 - Dec 2, 2020
+
+### Added
+- Support for the Transactional API
+
+### Removed
+- `add_to_segment` and `remove_from_segment` methods
+- Support for non-JSON data
+
+### Changed
+- IDs in the URLs are now escaped.
+- Improved validations for data that's passed in.
+- Earlier, if you passed in an event name without a customer ID to the `track` method, we would create an anonymous event. That is now removed. To create an anonymous event, use the `anonymous_track` method.
+
 ## Customerio 2.2.1 - Mar 23, 2020
 
 - Add license to gemspec [#55](https://github.com/customerio/customerio-ruby/pull/55)

data/README.md

@@ -42,20 +42,15 @@ You'll be able to integrate **fully** with [Customer.io](http://customer.io) wit
 
 ### Setup
 
-Create an instance of the client with your [customer.io](http://customer.io) credentials
-which can be found on the [customer.io integration screen](https://fly.customer.io/account/customerio_integration).
+Create an instance of the client with your [Customer.io credentials](https://fly.customer.io/settings/api_credentials).
 
 If you're using Rails, create an initializer `config/initializers/customerio.rb`:
 
 ```ruby
-$customerio = Customerio::Client.new("YOUR SITE ID", "YOUR API SECRET KEY")
+$customerio = Customerio::Client.new("YOUR SITE ID", "YOUR API SECRET KEY", region: Customerio::Regions::US)
 ```
 
-If you'd like to send complex data to associate to a user as json, pass a json option:
-
-```ruby
-customerio = Customerio::Client.new("YOUR SITE ID", "YOUR API SECRET KEY", :json => true)
-```
+`region` is optional and takes one of two values—`US` or `EU`. If you do not specify your region, we assume that your account is based in the US (`US`). If your account is based in the EU and you do not provide the correct region (`EU`), we'll route requests to our EU data centers accordingly, however this may cause data to be logged in the US. 
 
 ### Identify logged in customers
 
@@ -127,7 +122,7 @@ encourage your customers to perform an action.
 $customerio.track(5, "purchase", :type => "socks", :price => "13.99")
 ```
 
-**Note:** If you'd like to track events which occurred in the past, you can include a `timestamp` attribute
+**Note:** If you want to track events which occurred in the past, you can include a `timestamp` attribute
 (in seconds since the epoch), and we'll use that as the date the event occurred.
 
 ```ruby
@@ -136,10 +131,18 @@ $customerio.track(5, "purchase", :type => "socks", :price => "13.99", :timestamp
 
 ### Tracking anonymous events
 
-You can also send anonymous events, for situations where you don't yet have a customer record but still want to trigger a campaign:
+You can also send anonymous events, for situations where you don't yet have a customer record yet. An anonymous event requires an `anonymous_id` representing the unknown person and an event `name`. When you identify a person, you can set their `anonymous_id` attribute. If [event merging](https://customer.io/docs/anonymous-events/#turn-on-merging) is turned on in your workspace, and the attribute matches the `anonymous_id` in one or more events that were logged within the last 30 days, we associate those events with the person.
+
+Anonymous events cannot trigger campaigns by themselves. To trigger a campaign, the anonymous event must be associated with a person within 72 hours of the `track_anonymous` request.
 
 ```ruby
-$customerio.anonymous_track("help_enquiry", :recipient => 'user@example.com')
+# Arguments
+# anonymous_id (required) - the id representing the unknown person.
+# name (required)         - the name of the event you want to track.
+# attributes (optional)   - any related information you want to attach to the
+#                           event.
+
+$customerio.track_anonymous(anonymous_id, "product_view", :type => "socks" )
 ```
 
 Use the `recipient` attribute to specify the email address to send the messages to. [See our documentation on how to use anonymous events for more details](https://learn.customer.io/recipes/invite-emails.html).
@@ -183,20 +186,51 @@ Start tracking events and identifies again for a previously suppressed customer.
 $customerio.unsuppress(5)
 ```
 
-### Add customers to a manual segment
+### Send Transactional Messages
 
-Add the list of customer ids to the specified manual segment. If you send customer ids that don't exist yet in an add_to_segment request, we will automatically create customer profiles for the new customer ids.
+To use the Customer.io [Transactional API](https://customer.io/docs/transactional-api), create an instance of the API client using an [app key](https://customer.io/docs/managing-credentials#app-api-keys).
 
-```ruby
-$customerio.add_to_segment(segment_id=1,customer_ids=['1','2','3'])
-```
+Create a new `SendEmailRequest` object containing:
+
+* `transactional_message_id`: the ID of the transactional message you want to send, or the `body`, `from`, and `subject` of a new message.
+* `to`: the email address of your recipients 
+* an `identifiers` object containing the `id` of your recipient. If the `id` does not exist, Customer.io creates it.
+* a `message_data` object containing properties that you want reference in your message using liquid.
+* You can also send attachments with your message. Use `attach` to encode attachments.
 
-### Remove customers from a manual segment
+Use `send_email` referencing your request to send a transactional message. [Learn more about transactional messages and `SendEmailRequest` properties](https://customer.io/docs/transactional-api).
 
-Remove the list of customer ids from the specified manual segment.
 
 ```ruby
-$customerio.remove_from_segment(segment_id=1,customer_ids=['1','2','3'])
+require "customerio"
+
+client = Customerio::APIClient.new("your API key", region: Customerio::Regions::US)
+
+request = Customerio::SendEmailRequest.new(
+  to: "person@example.com",
+  transactional_message_id: "3",
+  message_data: {
+    name: "Person",
+    items: {
+      name: "shoes",
+      price: "59.99",
+    },
+    products: [],
+  },
+  identifiers: {
+    id: "2",
+  },
+)
+
+file = File.open('<file-path>', 'r')
+request.attach("filename", file.read)
+
+begin
+  response = client.send_email(request)
+  puts response
+rescue Customerio::InvalidResponse => e
+  puts e.code, e.message
+end
 ```
 
 ## Contributing

data/customerio.gemspec

@@ -17,10 +17,10 @@ Gem::Specification.new do |gem|
   gem.version       = Customerio::VERSION
 
   gem.add_dependency('multi_json', "~> 1.0")
+  gem.add_dependency('addressable', '~> 2.8.0')
 
   gem.add_development_dependency('rake', '~> 10.5')
   gem.add_development_dependency('rspec', '3.3.0')
-  gem.add_development_dependency('webmock', '1.24.2')
-  gem.add_development_dependency('addressable', '~> 2.3.6')
+  gem.add_development_dependency('webmock', '3.6.0')
   gem.add_development_dependency('json')
 end

data/lib/customerio.rb

@@ -1,6 +1,10 @@
 require "customerio/version"
 
 module Customerio
+  require "customerio/regions"
+  require "customerio/base_client"
   require "customerio/client"
+  require "customerio/requests/send_email_request"
+  require "customerio/api"
   require "customerio/param_encoder"
 end

data/lib/customerio/api.rb

@@ -0,0 +1,35 @@
+require 'net/http'
+require 'multi_json'
+
+module Customerio
+  class APIClient
+    def initialize(app_key, options = {})
+      options[:region] = Customerio::Regions::US if options[:region].nil?
+      raise "region must be an instance of Customerio::Regions::Region" unless options[:region].is_a?(Customerio::Regions::Region)
+
+      options[:url] = options[:region].api_url if options[:url].nil? || options[:url].empty?
+      @client = Customerio::BaseClient.new({ app_key: app_key }, options)
+    end
+
+    def send_email(req)
+      raise "request must be an instance of Customerio::SendEmailRequest" unless req.is_a?(Customerio::SendEmailRequest)
+      response = @client.request(:post, send_email_path, req.message)
+
+      case response
+      when Net::HTTPSuccess then
+        JSON.parse(response.body)
+      when Net::HTTPBadRequest then
+        json = JSON.parse(response.body)
+        raise Customerio::InvalidResponse.new(response.code, json['meta']['error'], response)
+      else
+        raise InvalidResponse.new(response.code, response.body)
+      end
+    end
+
+    private
+
+    def send_email_path
+      "/v1/send/email"
+    end
+  end
+end

data/lib/customerio/base_client.rb

@@ -0,0 +1,87 @@
+require 'net/http'
+require 'multi_json'
+
+module Customerio
+  DEFAULT_TIMEOUT  = 10
+
+  class InvalidRequest < RuntimeError; end
+  class InvalidResponse < RuntimeError
+    attr_reader :code, :response
+
+    def initialize(code, body, response=nil)
+      @message = body
+      @code = code
+      @response = response
+
+      super(@message)
+    end
+  end
+
+  class BaseClient
+    def initialize(auth, options = {})
+      @auth = auth
+      @timeout = options[:timeout] || DEFAULT_TIMEOUT
+      @base_uri = options[:url]
+    end
+
+    def request(method, path, body = nil, headers = {})
+      execute(method, path, body, headers)
+    end
+
+    def request_and_verify_response(method, path, body = nil, headers = {})
+      verify_response(request(method, path, body, headers))
+    end
+
+    private
+
+    def execute(method, path, body = nil, headers = {})
+      uri = URI.join(@base_uri, path)
+
+      session = Net::HTTP.new(uri.host, uri.port)
+      session.use_ssl = (uri.scheme == 'https')
+      session.open_timeout = @timeout
+      session.read_timeout = @timeout
+
+      req = request_class(method).new(uri.path)
+
+      if @auth.has_key?(:site_id) && @auth.has_key?(:api_key)
+        req.initialize_http_header(headers)
+        req.basic_auth @auth[:site_id], @auth[:api_key]
+      else
+        headers['Authorization'] = "Bearer #{@auth[:app_key]}"
+        req.initialize_http_header(headers)
+      end
+
+      if !body.nil?
+        req.add_field('Content-Type', 'application/json')
+        req.body = MultiJson.dump(body)
+      end
+
+      session.start do |http|
+        http.request(req)
+      end
+    end
+
+    def request_class(method)
+      case method
+      when :post
+        Net::HTTP::Post
+      when :put
+        Net::HTTP::Put
+      when :delete
+        Net::HTTP::Delete
+      else
+        raise InvalidRequest.new("Invalid request method #{method.inspect}")
+      end
+    end
+
+    def verify_response(response)
+      case response
+      when Net::HTTPSuccess then
+        response
+      else
+        raise InvalidResponse.new(response.code, response.body, response)
+      end
+    end
+  end
+end

data/lib/customerio/client.rb

@@ -1,29 +1,22 @@
-require 'net/http'
-require 'multi_json'
+require "addressable/uri"
 
 module Customerio
-  DEFAULT_BASE_URI = 'https://track.customer.io'
-  DEFAULT_TIMEOUT  = 10
-
   class Client
+    PUSH_OPENED = 'opened'
+    PUSH_CONVERTED = 'converted'
+    PUSH_DELIVERED = 'delivered'
+
+    VALID_PUSH_EVENTS = [PUSH_OPENED, PUSH_CONVERTED, PUSH_DELIVERED]
+
     class MissingIdAttributeError < RuntimeError; end
     class ParamError < RuntimeError; end
-    class InvalidRequest < RuntimeError; end
-    class InvalidResponse < RuntimeError
-      attr_reader :response
 
-      def initialize(message, response)
-        super(message)
-        @response = response
-      end
-    end
+    def initialize(site_id, api_key, options = {})
+      options[:region] = Customerio::Regions::US if options[:region].nil?
+      raise "region must be an instance of Customerio::Regions::Region" unless options[:region].is_a?(Customerio::Regions::Region)
 
-    def initialize(site_id, secret_key, options = {})
-      @username = site_id
-      @password = secret_key
-      @json = options.has_key?(:json) ? options[:json] : true
-      @base_uri = options[:base_uri] || DEFAULT_BASE_URI
-      @timeout = options[:timeout] || DEFAULT_TIMEOUT
+      options[:url] = options[:region].track_url if options[:url].nil? || options[:url].empty?
+      @client = Customerio::BaseClient.new({ site_id: site_id, api_key: api_key }, options)
     end
 
     def identify(attributes)
@@ -31,41 +24,38 @@ module Customerio
     end
 
     def delete(customer_id)
-      verify_response(request(:delete, customer_path(customer_id)))
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      @client.request_and_verify_response(:delete, customer_path(customer_id))
     end
 
     def suppress(customer_id)
-      verify_response(request(:post, suppress_path(customer_id)))
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      @client.request_and_verify_response(:post, suppress_path(customer_id))
     end
 
     def unsuppress(customer_id)
-      verify_response(request(:post, unsuppress_path(customer_id)))
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      @client.request_and_verify_response(:post, unsuppress_path(customer_id))
     end
 
-    def track(*args)
-      attributes = extract_attributes(args)
-
-      if args.length == 1
-        # Only passed in an event name, create an anonymous event
-        event_name = args.first
-        create_anonymous_event(event_name, attributes)
-      else
-        # Passed in a customer id and an event name.
-        # Track the event for the given customer
-        customer_id, event_name = args
+    def track(customer_id, event_name, attributes = {})
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError.new("event_name must be a non-empty string") if is_empty?(event_name)
 
-        create_customer_event(customer_id, event_name, attributes)
-      end
+      create_customer_event(customer_id, event_name, attributes)
     end
 
-    def anonymous_track(event_name, attributes = {})
-      create_anonymous_event(event_name, attributes)
+    def track_anonymous(anonymous_id, event_name, attributes = {})
+      raise ParamError.new("anonymous_id must be a non-empty string") if is_empty?(anonymous_id)
+      raise ParamError.new("event_name must be a non-empty string") if is_empty?(event_name)
+
+      create_anonymous_event(anonymous_id, event_name, attributes)
     end
 
     def add_device(customer_id, device_id, platform, data={})
-      raise ParamError.new("customer_id must be a non-empty string") unless customer_id != "" and !customer_id.nil?
-      raise ParamError.new("device_id must be a non-empty string") unless device_id != "" and !device_id.nil?
-      raise ParamError.new("platform must be a non-empty string") unless platform != "" and !platform.nil?
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError.new("device_id must be a non-empty string") if is_empty?(device_id)
+      raise ParamError.new("platform must be a non-empty string") if is_empty?(platform)
 
       if data.nil?
         data = {}
@@ -73,155 +63,104 @@ module Customerio
 
       raise ParamError.new("data parameter must be a hash") unless data.is_a?(Hash)
 
-      verify_response(request(:put, device_path(customer_id), {
+      @client.request_and_verify_response(:put, device_path(customer_id), {
         :device => data.update({
           :id => device_id,
           :platform => platform,
         })
-      }))
+      })
     end
 
     def delete_device(customer_id, device_id)
-      raise ParamError.new("customer_id must be a non-empty string") unless customer_id != "" and !customer_id.nil?
-      raise ParamError.new("device_id must be a non-empty string") unless device_id != "" and !device_id.nil?
-      
-      verify_response(request(:delete, device_id_path(customer_id, device_id)))
-    end
+      raise ParamError.new("customer_id must be a non-empty string") if is_empty?(customer_id)
+      raise ParamError.new("device_id must be a non-empty string") if is_empty?(device_id)
 
-    def add_to_segment(segment_id, customer_ids)
-      raise ParamError.new("segment_id must be an integer") unless segment_id.is_a? Integer
-      raise ParamError.new("customer_ids must be a list of values") unless customer_ids.is_a? Array
-
-      customer_ids = customer_ids.map{ |id| id.to_s }
-
-      verify_response(request(:post, add_to_segment_path(segment_id), {
-        :ids => customer_ids,
-      }))
+      @client.request_and_verify_response(:delete, device_id_path(customer_id, device_id))
     end
 
-    def remove_from_segment(segment_id, customer_ids)
-      raise ParamError.new("segment_id must be an integer") unless segment_id.is_a? Integer
-      raise ParamError.new("customer_ids must be a list of values") unless customer_ids.is_a? Array
+    def track_push_notification_event(event_name, attributes = {})
+        keys = [:delivery_id, :device_id, :timestamp]
+        attributes = Hash[attributes.map { |(k,v)| [ k.to_sym, v ] }].
+            select { |k, v| keys.include?(k) }
+
+        raise ParamError.new('event_name must be one of opened, converted, or delivered') unless VALID_PUSH_EVENTS.include?(event_name)
+        raise ParamError.new('delivery_id must be a non-empty string') unless attributes[:delivery_id] != "" and !attributes[:delivery_id].nil?
+        raise ParamError.new('device_id must be a non-empty string') unless attributes[:device_id] != "" and !attributes[:device_id].nil?
+        raise ParamError.new('timestamp must be a valid timestamp') unless valid_timestamp?(attributes[:timestamp])
 
-      customer_ids = customer_ids.map{ |id| id.to_s }
-      
-      verify_response(request(:post, remove_from_segment_path(segment_id), {
-        :ids => customer_ids,
-      }))
+        @client.request_and_verify_response(:post, track_push_notification_event_path, attributes.merge(event: event_name))
     end
 
     private
 
-    def add_to_segment_path(segment_id)
-      "/api/v1/segments/#{segment_id}/add_customers"
-    end
-
-    def remove_from_segment_path(segment_id)
-      "/api/v1/segments/#{segment_id}/remove_customers"
+    def escape(val)
+      # CGI.escape is recommended for escaping, however, it doesn't correctly escape spaces.
+      Addressable::URI.encode_component(val.to_s, Addressable::URI::CharacterClasses::UNRESERVED)
     end
 
     def device_path(customer_id)
-      "/api/v1/customers/#{customer_id}/devices"
+      "/api/v1/customers/#{escape(customer_id)}/devices"
     end
 
     def device_id_path(customer_id, device_id)
-      "/api/v1/customers/#{customer_id}/devices/#{device_id}"
-    end
-
-    def create_or_update(attributes = {})
-      attributes = Hash[attributes.map { |(k,v)| [ k.to_sym, v ] }]
-
-      raise MissingIdAttributeError.new("Must provide a customer id") unless attributes[:id]
-
-      url = customer_path(attributes[:id])
-
-      verify_response(request(:put, url, attributes))
-    end
-
-    def create_customer_event(customer_id, event_name, attributes = {})
-      create_event("#{customer_path(customer_id)}/events", event_name, attributes)
-    end
-
-    def create_anonymous_event(event_name, attributes = {})
-      create_event("/api/v1/events", event_name, attributes)
-    end
-
-    def create_event(url, event_name, attributes = {})
-      body = { :name => event_name, :data => attributes }
-      body[:timestamp] = attributes[:timestamp] if valid_timestamp?(attributes[:timestamp])
-      verify_response(request(:post, url, body))
+      "/api/v1/customers/#{escape(customer_id)}/devices/#{escape(device_id)}"
     end
 
     def customer_path(id)
-      "/api/v1/customers/#{id}"
+      "/api/v1/customers/#{escape(id)}"
     end
 
     def suppress_path(customer_id)
-      "/api/v1/customers/#{customer_id}/suppress"
+      "/api/v1/customers/#{escape(customer_id)}/suppress"
     end
 
     def unsuppress_path(customer_id)
-      "/api/v1/customers/#{customer_id}/unsuppress"
+      "/api/v1/customers/#{escape(customer_id)}/unsuppress"
     end
 
-    def valid_timestamp?(timestamp)
-      timestamp && timestamp.is_a?(Integer) && timestamp > 999999999 && timestamp < 100000000000
+    def track_push_notification_event_path
+        "/push/events"
     end
 
+    def create_or_update(attributes = {})
+      attributes = Hash[attributes.map { |(k,v)| [ k.to_sym, v ] }]
+      raise MissingIdAttributeError.new("Must provide a customer id") if is_empty?(attributes[:id])
 
-    def verify_response(response)
-      if response.code.to_i >= 200 && response.code.to_i < 300
-        response
-      else
-        raise InvalidResponse.new("Customer.io API returned an invalid response: #{response.code}", response)
-      end
+      url = customer_path(attributes[:id])
+      @client.request_and_verify_response(:put, url, attributes)
     end
 
-    def extract_attributes(args)
-      hash = args.last.is_a?(Hash) ? args.pop : {}
-      hash.inject({}){ |hash, (k,v)| hash[k.to_sym] = v; hash }
+    def create_customer_event(customer_id, event_name, attributes = {})
+      create_event(
+        url: "#{customer_path(customer_id)}/events",
+        event_name: event_name,
+        attributes: attributes
+      )
     end
 
-    def request(method, path, body = nil, headers = {})
-      uri = URI.join(@base_uri, path)
-
-      session = Net::HTTP.new(uri.host, uri.port)
-      session.use_ssl = (uri.scheme == 'https')
-      session.open_timeout = @timeout
-      session.read_timeout = @timeout
-
-      req = request_class(method).new(uri.path)
-      req.initialize_http_header(headers)
-      req.basic_auth @username, @password
+    def create_anonymous_event(anonymous_id, event_name, attributes = {})
+      create_event(
+        url: "/api/v1/events",
+        event_name: event_name,
+        anonymous_id: anonymous_id,
+        attributes: attributes
+      )
+    end
 
-      add_request_body(req, body) unless body.nil?
+    def create_event(url:, event_name:, anonymous_id: nil, attributes: {})
+      body = { :name => event_name, :data => attributes }
+      body[:timestamp] = attributes[:timestamp] if valid_timestamp?(attributes[:timestamp])
+      body[:anonymous_id] = anonymous_id unless anonymous_id.nil?
 
-      session.start do |http|
-        http.request(req)
-      end
+      @client.request_and_verify_response(:post, url, body)
     end
 
-    def request_class(method)
-      case method
-      when :post
-        Net::HTTP::Post
-      when :put
-        Net::HTTP::Put
-      when :delete
-        Net::HTTP::Delete
-      else
-        raise InvalidRequest.new("Invalid request method #{method.inspect}")
-      end
+    def valid_timestamp?(timestamp)
+      timestamp && timestamp.is_a?(Integer) && timestamp > 999999999 && timestamp < 100000000000
     end
 
-    def add_request_body(req, body)
-      if @json
-        req.add_field('Content-Type', 'application/json')
-        req.body = MultiJson.dump(body)
-      else
-        req.add_field('Content-Type', 'application/x-www-form-urlencoded')
-        req.body = ParamEncoder.to_params(body)
-      end
+    def is_empty?(val)
+      val.nil? || (val.is_a?(String) && val.strip == "")
     end
   end
 end