logcamp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aca5ccf7efebae1e58f0478f31513e2879476186
+  data.tar.gz: d71ce91b422f4b7315cfe28812bacb3eef3d9eac
+SHA512:
+  metadata.gz: ae62badee2be9561b800df11817428d248c1c1930e3b06347930da64dd077b9a1635286351a2b2c78355f0789322d27f9723d0a467e008963c0fec04c2475d35
+  data.tar.gz: 0fed04155057e5889e74cd936778d5c6c1a63442f285de45d3dd2a65aedc43f53bab1fcbf0fe133efc83639dc82a02b5f515008fd4d4945ee7816f744044bab2

data/README.md

@@ -0,0 +1,52 @@
+# Logcamp::Ruby
+
+[![Build Status](https://semaphoreapp.com/api/v1/projects/0d7ed887-f4de-410c-a678-eb47c9c66aa8/275246/shields_badge.svg)](https://semaphoreapp.com/olimart/logcamp-ruby)
+
+Simple gem for communicating with external API. Heavily inspired by stripe gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'logcamp-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logcamp-ruby
+
+## Usage
+
+In your app
+
+1. Set token
+
+```ruby
+Logcamp.token = ENV['LOGCAMP_TOKEN']
+```
+
+2. Send event
+
+```ruby
+Logcamp::Event.create(
+  status: 'event status',
+  message: 'notification message',
+  alert: true,
+  metadata: {
+    key1: value1,
+    key2: value2
+  }
+)
+```
+
+**For Sinatra app** you may need to add `require 'bundler/setup'`
+
+
+## Tests
+
+```ruby
+rake test
+```

data/lib/logcamp.rb

@@ -0,0 +1,145 @@
+# Logcamp Ruby bindings
+require "cgi"
+require "set"
+require "openssl"
+require "json"
+require "net/http"
+require "uri"
+
+# Version
+require "logcamp/version"
+
+# API operations
+require "logcamp/api_operations/create"
+
+# Resources
+require "logcamp/logcamp_object"
+require "logcamp/api_resource"
+require "logcamp/event"
+
+# Errors
+require "logcamp/errors/logcamp_error"
+require "logcamp/errors/api_error"
+require "logcamp/errors/api_connection_error"
+require "logcamp/errors/invalid_request_error"
+require "logcamp/errors/invalid_metadata_error"
+require "logcamp/errors/authentication_error"
+
+module Logcamp
+  @api_base = "https://logcamp.herokuapp.com/api"
+
+  class << self
+    attr_accessor :token, :api_base, :verify_ssl_certs, :api_version
+  end
+
+  def self.api_url(url="")
+    @api_base + url
+  end
+
+  def self.request(method, url, token, params={}, headers={})
+    unless token ||= @token
+      raise AuthenticationError.new("No token provided")
+    end
+
+    if !params[:metadata].nil? && params[:metadata].class != Hash
+      raise InvalidMetadataError.new("Invalid metadata. Only key value pair is supported", params)
+    else
+      params[:metadata] = params[:metadata].to_json
+    end
+
+    url = api_url(url)
+
+    begin
+
+      uri = URI(url)
+      request = Net::HTTP::Post.new(uri) if method == :post
+
+      request["User-Agent"]    = "Logcamp-ruby gem"
+      request["Authorization"] = "Token token=\"#{token}\""
+      request["Content-Type"]  = "application/json"
+      request.body = params.to_json
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+
+      # see http://www.rubyinside.com/how-to-cure-nethttps-risky-default-https-behavior-4010.html
+      # for info about ssl verification
+
+      http.use_ssl = true if uri.scheme == "https"
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if uri.scheme == "https"
+
+      response = http.start {|h|
+        h.request(request)
+      }
+
+      # since http.request doesn't throw such exceptions, check them by status codes
+      handle_api_error(response.code, response.body)
+
+    rescue SocketError => e
+      handle_connection_error(e)
+    rescue NoMethodError => e
+      handle_connection_error(e)
+    rescue OpenSSL::SSL::SSLError => e
+      handle_connection_error(e)
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
+      handle_connection_error(e)
+    rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, InvalidMetadataError  => e
+      handle_connection_error(e)
+    end
+
+    [response, token]
+  end
+
+  def self.handle_connection_error(e)
+    case e
+      when SocketError
+        message = "Unexpected error when trying to connect to Logcamp"
+      when NoMethodError
+        message = "Unexpected HTTP response code"
+      when InvalidMetadataError
+        message = "Invalid metadata. Only key value pair is supported"
+      else
+        message = "Unexpected error communicating with Logcamp"
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = JSON.parse(rbody)
+    rescue JSON::ParserError
+      raise general_api_error(rcode, rbody)
+    end
+
+    case rcode
+      when 400, 404, 422
+        raise invalid_request_error error, rcode, rbody, error_obj
+      when 401
+        raise authentication_error error, rcode, rbody, error_obj
+      when 500
+        raise api_error error, rcode, rbody, error_obj
+      else
+        # raise api_error error, rcode, rbody, error_obj
+    end
+
+  end
+
+  def self.invalid_request_error(error, rcode, rbody, error_obj)
+    InvalidRequestError.new(error[:message], error[:param], rcode,
+                            rbody, error_obj)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.general_api_error(rcode, rbody)
+    APIError.new("Invalid response object from API: #{rbody.inspect} " +
+                 "(HTTP response code was #{rcode})", rcode, rbody)
+  end
+end

data/lib/logcamp/api_operations/create.rb

@@ -0,0 +1,16 @@
+module Logcamp
+  module APIOperations
+    module Create
+      module ClassMethods
+        def create(params={}, token=nil)
+          response, token = Logcamp.request(:post, self.url, token, params)
+          response
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/logcamp/api_resource.rb

@@ -0,0 +1,21 @@
+module Logcamp
+  class APIResource < LogcampObject
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.url()
+      if self == APIResource
+        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses)')
+      end
+      "/#{CGI.escape(class_name.downcase)}s"
+    end
+
+    def url
+      unless id = self['id']
+        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+      end
+      "#{self.class.url}/#{CGI.escape(id)}"
+    end
+  end
+end

data/lib/logcamp/errors/api_connection_error.rb

@@ -0,0 +1,4 @@
+module Logcamp
+  class APIConnectionError < LogcampError
+  end
+end

data/lib/logcamp/errors/api_error.rb

@@ -0,0 +1,4 @@
+module Logcamp
+  class APIError < LogcampError
+  end
+end

data/lib/logcamp/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module Logcamp
+  class AuthenticationError < LogcampError
+  end
+end

data/lib/logcamp/errors/invalid_metadata_error.rb

@@ -0,0 +1,4 @@
+module Logcamp
+  class InvalidMetadataError < LogcampError
+  end
+end

data/lib/logcamp/errors/invalid_request_error.rb

@@ -0,0 +1,10 @@
+module Logcamp
+  class InvalidRequestError < LogcampError
+    attr_accessor :param
+
+    def initialize(message, param, http_status=nil, http_body=nil, json_body=nil)
+      super(message, http_status, http_body, json_body)
+      @param = param
+    end
+  end
+end

data/lib/logcamp/errors/logcamp_error.rb

@@ -0,0 +1,20 @@
+module Logcamp
+  class LogcampError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/logcamp/event.rb

@@ -0,0 +1,6 @@
+module Logcamp
+  class Event < APIResource
+    include Logcamp::APIOperations::Create
+
+  end
+end

data/lib/logcamp/logcamp_object.rb

@@ -0,0 +1,5 @@
+module Logcamp
+  class LogcampObject
+
+  end
+end

data/lib/logcamp/version.rb

@@ -0,0 +1,3 @@
+module Logcamp
+  VERSION = "0.0.1"
+end

data/test/logcamp/event_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Logcamp
+  class EventTest < Test::Unit::TestCase
+    should "create should return status 201" do
+      response = Logcamp::Event.create(status: 'success', message: 'Event occured',
+                                       alert: true,
+                                       metadata: { date: Time.now })
+      assert_equal "201", response.code
+    end
+
+    should "raise Logcamp::AuthenticationError if no token provided" do
+      Logcamp.token = nil
+      assert_raises(Logcamp::AuthenticationError) { Logcamp::Event.create }
+    end
+
+    should "raise Logcamp::InvalidRequestError if not enough parameters" do
+      begin
+      rescue JSON::ParserError
+        assert_raises(Logcamp::InvalidRequestError) { Logcamp::Event.create }
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require "logcamp"
+require "test/unit"
+require "shoulda"
+
+class Test::Unit::TestCase
+
+  setup do
+    Logcamp.token = "111"
+  end
+
+  teardown do
+    Logcamp.token = nil
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: logcamp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Olivier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+description: Aggregate app notifications in one place. Search events and share access
+email:
+- olivier@yafoy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/logcamp.rb
+- lib/logcamp/api_operations/create.rb
+- lib/logcamp/api_resource.rb
+- lib/logcamp/errors/api_connection_error.rb
+- lib/logcamp/errors/api_error.rb
+- lib/logcamp/errors/authentication_error.rb
+- lib/logcamp/errors/invalid_metadata_error.rb
+- lib/logcamp/errors/invalid_request_error.rb
+- lib/logcamp/errors/logcamp_error.rb
+- lib/logcamp/event.rb
+- lib/logcamp/logcamp_object.rb
+- lib/logcamp/version.rb
+- test/logcamp/event_test.rb
+- test/test_helper.rb
+homepage: https://github.com/camplog/logcamp-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Gem to send app-generated event notifications to logcamp master application
+test_files:
+- test/logcamp/event_test.rb
+- test/test_helper.rb