gnip_api 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4b23aa44097600cdcd2a60ed769511a39999a6a
-  data.tar.gz: b94409aca9eb2a64c653ba006a45db6c3fb3d806
+  metadata.gz: 515a1f5c48c72c4f23dfc7e4882d6f7b8b47067c
+  data.tar.gz: f4775d00111fb0811aefb798aa178357927ccf02
 SHA512:
-  metadata.gz: e66a5a77b304723a7a8416f6d4674426c19ae70526ea3eeeb94473ec8beaa09b5942918b02b92c933cbc948b50db10b57c6080df08b527168c88c7a500fb0dbd
-  data.tar.gz: 8c886b7b16b51c2461885a33e11f1813b5fc847acccc43e0d6cad47d1956bfb490a4a4d5ab9c964d8f026b26bac0d4dc27673c661485b1547889abf65fcbae2d
+  metadata.gz: 358bd8b2aba8653f782a747793b1f4580712ef74c3b188ef9a5fd65dfb8cd5cfeab1d8238327a147b42a9226abc925bab2999bb83c74f929abb917fe0a9c0ebd
+  data.tar.gz: 89bd54df5d5e31a04f467996e104651c4ace873de6748a96d33788eaf89e01d022aa26f3c81f8261998a138346f9ebcdc192ca2c5f5426267cbc7502bad0df10

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gnip_api (1.1.3)
+    gnip_api (1.2.0)
       addressable
       httparty
       yajl-ruby

data/README.md

@@ -6,11 +6,9 @@ Connect with different Gnip APIs and get data from streams.
 
 ## Recent Changes
 
-- Added a debug mode to output more information on logger from adapter
-- 2.0 APIs implemented partially, more will come soon
-- Fixed a memory issue with HTTParty
-- Timeout for requests added to fail if API is non responsive, time can be configured
-- Search API returns parsed data either for counts or activities, which also makes Search API usable to get activities now
+- Removed adapter customization and opted to use HTTParty as main adapter
+- Removed output option for stream
+- Added different methods for consuming stream
 
 ## Notes
 
@@ -43,7 +41,6 @@ GnipApi.configure |config|
   config.user = 'someone' # Gnip Account Username
   config.password = 'something' # Gnip Password
   config.account = 'myGnipAccount' # Your accounts name
-  config.adapter_class = SomeAdapter # You can define your own adapter, more in the following section
   config.logger = Logger.new('myLog.log') # You can also provide a custom logger
   config.source = 'twitter' # General source, if none defined when quering, this will be used
   config.label = 'mystream' # General stream label, if none defined when quering, this will be used
@@ -83,19 +80,19 @@ The Search API allows you to get counts or activities in a time period, with a m
 To access the Search API you will need a rule first, you can use PowerTrack Rule object for it:
 
 ```ruby
-rule = GnipApi::Apis::PowerTrack::Rule.new :value => 'keyword1 OR keyword2'
+rule = GnipApi::PowerTrack::Rule.new :value => 'keyword1 OR keyword2'
 ```
 
 Then you can query the search endpoint to get counts or activities. For counts:
 
 ```ruby
-results = GnipApi::Apis::Search.new.counts :rule => rule
+results = GnipApi::Search.new.counts :rule => rule
 ```
 
 For activities:
 
 ```ruby
-results = GnipApi::Apis::Search.new.activities :rule => rule
+results = GnipApi::Search.new.activities :rule => rule
 ```
 
 Responses are parsed, so you can then use the output normally as any other Ruby object. For the case of activities, they get converted to Gnip::Activity objects, and have all the rest parsed as they would came from stream.
@@ -103,19 +100,19 @@ Responses are parsed, so you can then use the output normally as any other Ruby
 You can set different parameters:
 
 ```ruby
-results = GnipApi::Apis::Search.new.counts :rule => rule, :from_date => DateTime.parse('2016-01-01 00:00'), :to_date => DateTime.parse('2016-05-01 22:00'), :bucket => 'day'
+results = GnipApi::Search.new.counts :rule => rule, :from_date => DateTime.parse('2016-01-01 00:00'), :to_date => DateTime.parse('2016-05-01 22:00'), :bucket => 'day'
 ```
 
 For activities, there are a few extra considerations:
 
 - A param ```:max_results``` indicates how many activities to return on a response, valid values are from 10 to 500, default is 100, this param does not work on counts.
-- As you noticed, you pass a ```GnipApi::Apis::PowerTrack::Rule``` object to the search endpoint, and as you may also know, these objects have mostly 2 things: value (actual rule), and tag. When querying activities on the Search API, you can optionally use a tag that is returned on the activity, along with the rule. This tag is deduced from the rule object you pass, in other words, if you want a tag, add it on the ```GnipApi::Apis::PowerTrack::Rule``` object, it's not a valid param for the method.
+- As you noticed, you pass a ```GnipApi::PowerTrack::Rule``` object to the search endpoint, and as you may also know, these objects have mostly 2 things: value (actual rule), and tag. When querying activities on the Search API, you can optionally use a tag that is returned on the activity, along with the rule. This tag is deduced from the rule object you pass, in other words, if you want a tag, add it on the ```GnipApi::PowerTrack::Rule``` object, it's not a valid param for the method.
 - The ```:bucket``` option is only for counts.
 
 When you query for more than 30 days or more activities than ```:max_results```, the results will include a ```:next``` token to iterate over the remaining pages. You can instantly feed this token to a following request with same parameters:
 
 ```ruby
-results = GnipApi::Apis::Search.new.counts :rule => rule, :from_date => DateTime.parse('2016-01-01 00:00'), :to_date => DateTime.parse('2016-05-01 22:00'), :bucket => 'day', :next_token => 'token_from_previous_request'
+results = GnipApi::Search.new.counts :rule => rule, :from_date => DateTime.parse('2016-01-01 00:00'), :to_date => DateTime.parse('2016-05-01 22:00'), :bucket => 'day', :next_token => 'token_from_previous_request'
 ```
 
 ### PowerTrack
@@ -124,14 +121,14 @@ PowerTrack API has various functions. You can upload, delete and get rules and y
 
 ```ruby
 rules = [] 
-rules << GnipApi::Apis::PowerTrack::Rule.new :value => 'keyword1 OR keyword2', :tag => 'first_rule'
-rules << GnipApi::Apis::PowerTrack::Rule.new :value => 'keyword3 keyword4', :tag => 'second_rule'
+rules << GnipApi::PowerTrack::Rule.new :value => 'keyword1 OR keyword2', :tag => 'first_rule'
+rules << GnipApi::PowerTrack::Rule.new :value => 'keyword3 keyword4', :tag => 'second_rule'
 ```
 
 Once you have your rule objects set, you can put them into an array and feed them to the PowerTrack Rules API:
 
 ```ruby
-GnipApi::Apis::PowerTrack::Rules.new.create rules
+GnipApi::PowerTrack::Rules.new.create rules
 ```
 
 That will upload the rules to the stream. The endpoint doesn't return anything on success but it will validate rules before applying and any syntax error will be raised as an error.
@@ -139,13 +136,13 @@ That will upload the rules to the stream. The endpoint doesn't return anything o
 To get a list of rules defined in the stream:
 
 ```ruby
-GnipApi::Apis::PowerTrack::Rules.new.list
+GnipApi::PowerTrack::Rules.new.list
 ```
 
-That will return an array of GnipRule::Apis::PowerTrack::Rule objects. In the same way as the upload the delete method removes 1 or more rules:
+That will return an array of GnipRule::PowerTrack::Rule objects. In the same way as the upload the delete method removes 1 or more rules:
 
 ```ruby
-GnipApi::Apis::PowerTrack::Rules.new.delete rules
+GnipApi::PowerTrack::Rules.new.delete rules
 ```
 
 Same as upload, no response from Gnip when deleting.
@@ -154,7 +151,7 @@ Same as upload, no response from Gnip when deleting.
 Finally, you can stream the activities and do something with them:
 
 ```ruby
-GnipApi::Apis::PowerTrack::Stream.new.consume do |messages|
+GnipApi::PowerTrack::Stream.new.consume do |messages|
   messages.select{|m| m.activity?}.each{|a| puts a.body}
   messages.select{|m| m.system_message?}.each{|s| puts s.message}
 end
@@ -167,24 +164,6 @@ There are a few considerations to make when doing this:
 - Be careful when putting this into a daemon, closing the stream can be tricky given how this was done
 - I've experience issues with a Zlib error that I currently couldn't debug and fix, if you build a daemon for this, be sure to code restart procedures
 
-### Adapters
-
-GnipApi is not dependent of a single adapter (there's a dependency with HTTParty, but shhh... it won't last too long). You can use one of the provided adapters, or you can make your own, using the BaseAdapter class. You only need to implement the desired connector POST, GET and DELETE methods. There's an extra stream_get method, but it's just a variant of GET. Keep in mind that Gnip uses compression, I found out that Excon doesn't decompress responses by default, just to name an example.
-The custom adapter does not require to live within the gem files, as long as GnipApi has access to your class, just put it in the config and you're ready to go. See the current adapters for reference.
-
-## Debug mode
-
-At any time you can enable/disable the debug mode like this:
-
-```ruby
-GnipApi.configuration.debug = true
-```
-
-This will output information about the request/response. Response body is not returned to avoid excessive logging.
-
-Note that debug data is dependent on what adapter you are using. You should be able to dump the necesary information from
-your adapter and call the internal debugger to log the information.
-
 ## WIP State
 
 GnipApi is a WIP. Call it a beta, alpha, gem that has part of the features, whatever. It is currently usable and it's being used by... well.. me. The custom adapter feature is there, and some of the APIs of Gnip were implemented. I'll be coding more things into this, such as other APIs, request retries, error handling, different adapters for known connectors like RestClient or HTTP/net, etc.

data/lib/gnip_api/adapter.rb

@@ -4,62 +4,76 @@ module GnipApi
     POST = 'POST'
     DELETE = 'DELETE'
 
-    attr_reader :adapter
+    attr_reader :logger, :debug
 
     def initialize
       raise GnipApi::Errors::MissingCredentials unless GnipApi.credentials?
-      raise GnipApi::Errors::MissingAdapter unless GnipApi.adapter_class?
-      @adapter = GnipApi.config.adapter_class.new
       @logger = GnipApi.config.logger
       @debug = GnipApi.config.debug
     end
 
     def get request
-      log_request(request)
-      response = adapter.get(request)
-      check_response_for_errors(response)
+      request.log!
+      data = HTTParty.get request.uri, :basic_auth => auth, :timeout => default_timeout
+      response = create_response(request, data.code, data.body, data.headers)
+      response.check_for_errors!
       return response.body unless response.body.empty?
       return true
     end
 
     def post request
-      log_request(request)
-      response = adapter.post(request)
-      check_response_for_errors(response)
+      request.log!
+      data = HTTParty.post request.uri, :basic_auth => auth, :body => request.payload, :timeout => default_timeout
+      response = create_response(request, data.code, data.body, data.headers)
+      response.check_for_errors!
       return response.body unless response.body.empty?
       return true
     end
 
     def delete request
-      log_request(request)
-      response = adapter.delete(request)
-      check_response_for_errors(response)
+      request.log!
+      data = HTTParty.post request.uri, :basic_auth => auth, :body => request.payload, :timeout => default_timeout
+      response = create_response(request, data.code, data.body, data.headers)
+      response.check_for_errors!
       return response.body unless response.body.empty?
       return true
     end
 
     def stream_get request
-      log_request(request)
-      adapter.stream_get(request) do |data|
-        yield(data)
+      request.log!
+      begin
+        HTTParty.get request.uri, :headers => request.headers, :stream_body => true, :basic_auth => auth do |data|
+          yield(data)
+        end
+      rescue Zlib::BufError => error
+        GnipApi.config.logger.error "STREAM ERROR -> #{error.class} -- #{error.message}\n" + error.backtrace.join("\n")
+        raise error
       end
     end
 
-    def check_response_for_errors response
-      if response.ok?
-        @logger.info "#{response.request_method} request to #{response.request_uri} returned with status #{response.status} OK"
-      else
-        error_message = response.error_message
-        @logger.error "#{response.request_method} request to #{response.request_uri} returned with status #{response.status} FAIL: #{error_message}"
-        raise GnipApi::Errors::Adapter::GnipSoftwareError.new error_message if response.status == 503 || response.status == '503'
-        raise GnipApi::Errors::Adapter::RateLimitError.new error_message if response.status == 429 || response.status == '429'
-        raise GnipApi::Errors::Adapter::RequestError.new error_message
-      end
+    private
+    def auth
+      {
+        :username => username,
+        :password => password
+      }
     end
 
-    private
-    def log_request request
-      @logger.info "Starting #{request.request_method} request to #{request.uri}"
+    def username
+      GnipApi.configuration.user
+    end
+
+    def password
+      GnipApi.configuration.password
     end
+
+    def default_timeout
+      GnipApi.configuration.request_timeout
+    end
+
+    def create_response request, status, body, headers
+      GnipApi::Response.new request, status, body, headers
+    end
+
   end
 end

data/lib/gnip_api/configuration.rb

@@ -1,17 +1,15 @@
 module GnipApi
   class Configuration
-    OUTPUT_FORMATS = [:activity, :json, :parsed_json]
-
-    attr_accessor :user, :password, :adapter_class, :account, :logger, :source, :label, :request_timeout, :debug, 
-                  :stream_output_format, :enable_gzip
+    attr_accessor :user, :password, :account, :logger, :source, :label, :request_timeout, :debug, 
+                  :enable_gzip, :log_level, :buffer_limit
 
     def initialize
-      @adapter_class = GnipApi::Adapters::HTTPartyAdapter
       @logger = Logger.new('tmp/gnip_api.log')
       @request_timeout = 60
       @debug = false
-      @stream_output_format = :activity
       @enable_gzip = true
+      @log_level = Logger::INFO
+      @logger.level = @log_level
     end
   end
 end

data/lib/gnip_api/errors.rb

@@ -34,6 +34,9 @@ module GnipApi
     end
 
     module PowerTrack
+      class StreamDown < StandardError; end
+      class BufferTooBig < StandardError; end
+
       class MissingRules < StandardError
         def initialize
           @message = 'No rules provided to operate'

data/lib/gnip_api/gnip/gnip_data.rb

@@ -3,7 +3,7 @@ module Gnip
     attr_reader :matching_rules, :urls, :language
 
     def initialize params={}
-      @matching_rules = params['matching_rules'].map{|r| GnipApi::Apis::PowerTrack::Rule.new(r)} if params['matching_rules']
+      @matching_rules = params['matching_rules'].map{|r| GnipApi::PowerTrack::Rule.new(r)} if params['matching_rules']
       @urls = (params['urls'] ? params['urls'].map{|u| Gnip::Url.new(u)} : [])
       @language = params['language']
     end

data/lib/gnip_api/gnip/system_message.rb

@@ -27,5 +27,9 @@ module Gnip
     def to_json
       @raw.to_json
     end
+
+    def log!
+      GnipApi.logger.warn "System Message Received: #{message_type} -- #{message} at #{sent}"
+    end
   end
 end

data/lib/gnip_api/power_track/buffer.rb

@@ -0,0 +1,42 @@
+module GnipApi
+  module PowerTrack
+    class Buffer
+      attr_reader :terminator, :data
+      
+      def initialize options={}
+        @terminator = options.delete(:terminator) || "\r\n"
+        @data = ""
+        @limit = GnipApi.config.buffer_limit
+      end
+      
+      def size
+        @data.size
+      end
+      
+      def insert! chunk
+        @data << chunk
+      end
+
+      def read!
+        objects = @data.split(terminator)[0..-2]
+        unless objects.empty?
+          # Get the number of chars to read from buffer, counting
+          # the size of each splited chunk plus the number of chunks by
+          # terminator size, since it's still present in the buffer
+          size = objects.map(&:size).reduce(:+) + objects.size * terminator.size
+          consume!(size)
+        end
+        return objects
+      end
+
+      def consume! chars
+        @data[0..chars-1] = ''
+      end
+
+      def over_limit?
+        return false unless @limit
+        return size > @limit
+      end
+    end
+  end
+end

data/lib/gnip_api/power_track/rule.rb

@@ -0,0 +1,77 @@
+module GnipApi
+  module PowerTrack
+    # Represents a PowerTrack rule with its necesary attribures.
+    class Rule
+      attr_accessor :value, :tag, :id
+
+      def initialize params={}
+        @value = params[:value] || params['value']
+        @tag = params[:tag] || params['tag']
+        @id = params[:id] || params['id']
+      end
+
+      def to_json
+        attributes.to_json
+      end
+
+      def attributes
+        attrs = {}
+        attrs[:value] = @value if @value
+        attrs[:tag] = @tag if @tag
+        attrs[:id] = @id if @id
+        attrs
+      end
+
+      def uid
+        rule = @value
+        rule += "tag:#{@tag}" if @tag
+        Digest::SHA2.hexdigest(rule)
+      end
+
+      # Simply checks balance of quotes and parenthesis within the value. Quoted text
+      # is sort of escaped as long as it's consistently quoted.
+      def consistent? raise_error=false
+        characters = value.chars
+        parenthesis = 0
+        in_double_quotes = false
+        in_single_quotes = false
+        char = characters.shift
+        while char
+          parenthesis += 1 if (char == '(')
+          parenthesis -= 1 if (char == ')')
+
+          if char == '"'
+            in_double_quotes = true
+            char = characters.shift
+            while char != '"'
+              char = characters.shift
+              break if char.nil?
+            end
+            in_double_quotes = false if char == '"'
+          end
+
+          if char == "'"
+            in_single_quotes = true
+            char = characters.shift
+            while char != "'"
+              char = characters.shift
+              break if char.nil?
+            end
+            in_single_quotes = false if char == "'"
+          end
+
+          char = characters.shift
+        end
+
+        if raise_error
+          raise ArgumentError.new("Imbalanced parenthesis") if parenthesis != 0
+          raise ArgumentError.new("Imbalanced single quotes") if in_single_quotes != false
+          raise ArgumentError.new("Imbalanced double quotes") if in_double_quotes != false
+          return nil
+        end
+        return parenthesis == 0 && in_single_quotes == false && in_double_quotes == false
+      end
+
+    end
+  end
+end

data/lib/gnip_api/power_track/rule_validator.rb

@@ -0,0 +1,6 @@
+module GnipApi
+  module PowerTrack
+    class RuleValidator
+    end
+  end
+end

data/lib/gnip_api/power_track/rules.rb

@@ -0,0 +1,81 @@
+# Gnip PowerTrack Rules API
+#
+# Create, delete and list rules of a powetrack stream.
+
+module GnipApi
+  module PowerTrack
+    class Rules
+      attr_reader :adapter
+
+      # In order to do any operation, you need to specify:
+      # - label: the label of your stream
+      # - source: which data source to use (I think only twitter is available)
+      def initialize params={}
+        @adapter = GnipApi::Adapter.new
+        @label = params[:label] || GnipApi.config.label
+      end
+
+      # Returns an array of defined rules
+      def list
+        request = create_get_request
+        rules = adapter.get(request)
+        parse_rules(rules)
+      end
+
+      # Creates the specified rule. Parameters:
+      # - rules: GnipApi::PowerTrack::Rule object
+      def create rules
+        raise GnipApi::Errors::PowerTrack::MissingRules.new if rules.nil? || rules.empty?
+        request = create_post_request(construct_rules(rules))
+        response = adapter.post(request)
+        return true if response.nil?
+        return GnipApi::JsonParser.new.parse(response)
+      end
+
+      # Deletes the specified rule. Parameters:
+      # - rules: GnipApi::PowerTrack::Rule object
+      def delete rules
+        raise GnipApi::Errors::PowerTrack::MissingRules.new if rules.nil? || rules.empty?
+        request = create_delete_request(construct_rules(rules))
+        response = adapter.delete(request)
+        return true if response.nil?
+        return GnipApi::JsonParser.new.parse(response)
+      end
+
+      # Parses an array of GnipApi::PowerTrack::Rule objects
+      # to the necesary JSON format for the endpoint
+      def construct_rules rules
+        parsed_rules = {:rules => []}
+        rules.each do |rule|
+          parsed_rules[:rules] << rule.attributes
+        end
+        parsed_rules.to_json
+      end
+
+      def parse_rules data
+        parsed_data = GnipApi::JsonParser.new.parse(data)
+        parsed_data['rules'].map{|rule| GnipApi::PowerTrack::Rule.new(:value => rule['value'], :tag => rule['tag'], :id => rule['id'])}
+      end
+
+      private
+      def endpoint
+        GnipApi::Endpoints.powertrack_rules(@label)
+      end
+
+      def create_get_request
+        GnipApi::Request.new_get(endpoint)
+      end
+
+      def create_post_request payload
+        GnipApi::Request.new_post(endpoint, payload)
+      end
+      
+      def create_delete_request payload
+        delete_url = endpoint
+        delete_url.query = '_method=delete'
+        GnipApi::Request.new_delete(delete_url, payload)
+      end
+
+    end
+  end
+end

data/lib/gnip_api/power_track/stream.rb

@@ -0,0 +1,122 @@
+module GnipApi
+  module PowerTrack
+    class Stream
+      attr_reader :adapter
+      
+      def initialize params = {}
+        @stream = params[:stream] || GnipApi.config.label
+        @user = params[:user] || GnipApi.configuration.user
+        @password = params[:password] || GnipApi.configuration.password
+        @account = params[:account] || GnipApi.configuration.account
+        @adapter = GnipApi::Adapter.new
+        @buffer = GnipApi::PowerTrack::Buffer.new
+        @running = false
+      end
+
+      def logger
+        GnipApi.logger
+      end
+
+      # Consumes the stream using a streamer thread instead of a simple block.
+      # This way the streamer can fill in the buffer and the block consumes it periodically.
+      def thread_consume
+        streamer = Thread.new do
+          logger.info "Starting streamer Thread"
+          begin
+            read_stream
+          ensure
+            logger.warn "Streamer exited"
+          end
+        end
+
+        begin
+          loop do
+            logger.warn "Streamer is down" unless streamer.alive?
+            raise GnipApi::Errors::PowerTrack::StreamDown unless streamer.alive?
+            entries = @buffer.read!
+            entries.any? ? yield(process_entries(entries)) : sleep(0.1)
+          end
+        ensure
+          streamer.kill if streamer.alive?
+        end
+      end
+
+      def consume
+        read_stream do |data|
+          yield(process_entries(data))
+        end
+      end 
+
+      def consume_raw
+        read_stream do |data|
+          yield(data)
+        end
+      end 
+
+      def consume_json
+        read_stream do |data|
+          yield(data.map{|item| parse_json(item)})
+        end
+      end
+
+      def read_stream
+        request = create_request
+        logger.info "Opening PowerTrack parsed stream"
+        begin
+          adapter.stream_get request do |chunk|
+            stream_running!
+            @buffer.insert! chunk
+            yield @buffer.read! if block_given?
+          end
+        ensure
+          logger.warn "Closing stream"
+          @running = false
+        end
+      end
+
+      def process_entries entries
+        logger.debug "PowerTrack Stream: #{entries.size} items received"
+        data = entries.map{|e| parse_json(e)}.compact
+        data.map!{|e| build_message(e)} 
+        data.select(&:system_message?).each(&:log!)
+        return data
+      end
+
+      def build_message params
+        Gnip::Message.build(params)
+      end
+
+      def parse_json json
+        begin 
+          GnipApi::JsonParser.new.parse json
+        rescue GnipApi::Errors::JsonParser::ParseError
+          nil
+        end
+      end
+
+      private
+      def stream_running! buffer=nil, chunk=nil
+        unless @running
+          logger.info "PowerTrack stream open"
+          @running = true
+        end
+        raise GnipApi::Errors::PowerTrack::BufferTooBig if buffer.over_limit?
+        logger.warn "PowerTrack Stream: Buffer size is growing too big (slow consuming)" if buffer.size > 65536
+        logger.debug "PowerTrack Stream: Received chunk of #{chunk.size} bytes" if chunk
+        logger.debug "PowerTrack Stream: #{buffer.size} bytes in buffer" if buffer
+      end
+
+      def create_request 
+        headers = {}
+        headers['Accept-Encoding'] = 'gzip' if GnipApi.config.enable_gzip
+        headers['Accept-Encoding'] ||= 'json'
+        GnipApi::Request.new_get(endpoint, headers)
+      end
+
+      def endpoint
+        GnipApi::Endpoints.powertrack_stream(@stream)
+      end
+
+    end
+  end
+end

data/lib/gnip_api/request.rb

@@ -4,7 +4,7 @@ module GnipApi
 
     class << self
       def new_get uri, headers=nil
-        new(:uri => uri, :headers => headers, :request_method => GnipApi::Adapter::GET, )
+        new(:uri => uri, :headers => headers, :request_method => GnipApi::Adapter::GET)
       end
       
       def new_post uri, payload, headers=nil
@@ -22,5 +22,12 @@ module GnipApi
       @headers = params[:headers]
       @request_method = params[:request_method]
     end
+
+    def log!
+      GnipApi.logger.info "Starting #{request_method} request to #{uri}"
+      GnipApi.logger.debug "Headers -> #{headers.inspect}"
+      GnipApi.logger.debug "Payload -> #{payload.inspect}"
+    end
+    
   end
 end