koa 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc5945903a71ce2ab19ff84349e51f71b424168f
+  data.tar.gz: 0eb595a00c2ba2ea352c9d9e58efa822aa9b7005
+SHA512:
+  metadata.gz: dd417b6f9690c978be64f172c73125cc81c682b557bcfa484285707f3426fe025d5c0e3276e90e0a047e3b03a542fbc5468d30d471b6b59f14480ffcdb7d2191
+  data.tar.gz: 1273a8f1a20bc5748ef0caf33e4510272fcaecc81afc2b3fafaedebbace0657c70d11b7ad096757da84bc6f0b85222403a0c475e056bcf12c983d569346efe8f

data/lib/koa.rb

@@ -0,0 +1,12 @@
+module Koa
+end
+
+require 'koa/conf'
+require 'koa/health-check'
+require 'koa/logger'
+require 'koa/measurement'
+require 'koa/kik'
+require 'koa/rack-request-timer'
+require 'koa/request'
+require 'koa/sequel-logger'
+require 'koa/query-time'

data/lib/koa/conf.rb

@@ -0,0 +1,13 @@
+module Koa
+  module Conf
+
+    def self.env(k)
+      ENV[k]
+    end
+
+    def self.env!(k)
+      env(k) || raise("Must set #{k}")
+    end
+
+  end
+end

data/lib/koa/health-check.rb

@@ -0,0 +1,27 @@
+require 'json'
+require 'timeout'
+
+class Koa::HealthCheck
+  def self.call(env)
+    begin
+      Timeout::timeout(2) do
+        db_check
+      end
+    rescue => e
+      return [500, {"Content-Type" => "text/json"},
+        [JSON.dump({error: e.message})]]
+    end
+    [200, {"Content-Type" => "text/json"}, [JSON.dump({info: Time.now})]]
+  end
+
+  def self.db_check
+    query = "select * from information_schema.tables"
+    if defined?(ActiveRecord)
+      ActiveRecord::Base.connection.execute(query)
+    elsif defined?(Sequel)
+      c = Sequel.connect(ENV["DATABASE_URL"])
+      c.exec(query)
+      c.disconnect
+    end
+  end
+end

data/lib/koa/kik.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'net/http'
+require 'timeout'
+
+module Koa::Kik
+  def self.purchase(signedData, username, host)
+    Koa::Logger.measure_block("kikpurchase") do
+      url = "https://purchase.kik.com/verification/v1/check?u=#{username}&d=#{host}"
+      response = request_with_retry(url, signedData, 5)
+      if response.nil? or response.code.to_i != 200
+        code = (response and response.code)
+        code ||= "nil"
+        Koa::Logger.count("kikpurchase.fail", 1,
+          {source: code, username: username, signed_data: signedData})
+        return false
+      end
+      JSON.parse(response.body)
+    end
+  end
+  
+  def self.push(token, message, data)
+    Koa::Logger.measure_block("kikpush") do
+      url = "https://api.kik.com/push/v1/send"
+      body = {
+        token: token,
+        ticker: message,
+        data: data
+      }
+      response = request_with_retry(url, body.to_json, 1, 1)
+      response_code = (response && response.code)
+      response_code ||= "nil"
+      PushResponse.new(response).tap do |pr|
+        if pr.success?
+          Koa::Logger.count("notification_sent", 1)
+        else
+          Koa::Logger.count("notification_fail", 1, {source: response_code})
+        end
+      end
+    end
+  end
+  
+  def self.verify(signedData, username, host)
+    Koa::Logger.measure_block("kikverify") do
+      url = "https://auth.kik.com/verification/v1/check?u=#{username}&d=#{host}"
+      request_with_retry(url, signedData, 5).body
+    end
+  end
+  
+  def self.request_with_retry(url, body, tries, seconds = 2)
+    tries.times do
+      begin
+        Timeout::timeout(seconds) do 
+          return request(url, body)
+        end
+      rescue Timeout::Error
+        Koa::Logger.count("kiktimeout", 1)
+        nil
+      end
+    end
+  end
+  
+  def self.request(url, body)
+    uri = URI.parse(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    request = Net::HTTP::Post.new(uri.request_uri)
+    request.add_field('Content-Type', 'application/json')
+    request.add_field('Content-Length', body.size)
+    
+    request.body = body
+    http.request(request)
+  end
+  
+  class PushResponse
+    def initialize(response)
+      @response = response
+    end
+    
+    def success?
+      @response and @response.code.to_i == 200
+    end
+    
+    def bad_token?
+      @response and @response.code.to_i == 403
+    end
+  end
+end

data/lib/koa/leaderboard-client.rb

@@ -0,0 +1,55 @@
+require 'json'
+require 'securerandom'
+
+module Koa
+  module LeaderboardClient
+    URL = Conf.env!('LEADERBOARD_URL')
+    GAME_ID = Conf.env!('KOA_GAME_ID')
+
+    def self.get_leaderboards(limit)
+      Logger.measure_block("leaderboard-client.get-leaderboards") do
+        response = Koa::Request.make(
+          type: :get,
+          url: URL + "/boards",
+          data: {limit: limit, game_id: GAME_ID}
+        )
+        if response.successful?
+          JSON.parse(response.body)
+        else
+          {}
+        end
+      end
+    end
+
+    def self.get_user_scores(user_id)
+      Logger.measure_block("leaderboard-client.get-user-scores") do
+        response = Koa::Request.make(
+          type: :get,
+          url: URL + "/user_scores",
+          data: {game_id: GAME_ID, user_id: user_id}
+        )
+        if response.successful?
+          user_scores = JSON.parse(response.body)
+        end
+      end
+    end
+
+    def self.add_score(user_id, score)
+      Logger.measure_block("leaderboard-client.add-score") do
+        Koa::Request.make(
+          type: :put,
+          url: URL + "/score",
+          data: {
+            user_id: user_id,
+            score: score,
+            request_id: SecureRandom.uuid,
+            game_id: GAME_ID
+          },
+          tries: 3,
+          timeout: 5
+        )
+      end
+    end
+
+  end
+end

data/lib/koa/logger.rb

@@ -0,0 +1,85 @@
+$stdout.sync = true
+module Koa
+  class StringLogger
+    def initialize
+      @msgs = []
+    end
+    
+    def puts(msg)
+      @msgs << msg
+    end
+    
+    def flush
+      @msgs.length.times.map {@msgs.pop}
+    end
+  end
+  
+  module NullLogger
+    def self.puts(*args)
+      
+    end
+    
+    def self.flush(*args)
+      
+    end
+  end
+  
+  module Logger
+    def self.appname
+      @prefix ||= ENV['APP_NAME'].downcase if ENV['APP_NAME']
+      if defined? ::Rails
+        @prefix ||= Rails.application.class.parent_name.downcase+"."
+      end
+      @prefix ||= ""
+    end
+    
+    def self.prefix(name)
+      appname+name
+    end
+    
+    def self.librato_log(type, name, val, data)
+      name = prefix(name)
+      data["#{type}##{name}"] = val
+      log(data)
+    end
+    
+    def self.out=(o)
+      @out = o
+    end
+    
+    def self.out
+      @out || $stdout
+    end
+    
+    def self.log(data)
+      out.puts(stringify(data))
+    end
+    
+    def self.measure_block(name, data = {})
+      start = Time.now
+      result = yield
+      elapsed = (Time.now.to_f - start.to_f) * 1000
+      measure(name, elapsed.round.to_s+"ms")
+      result
+    end
+    
+    def self.count(name, val, data = {})
+      librato_log("count", name, val, data)
+    end
+    
+    def self.measure(name, val, data = {})
+      librato_log("measure", name, val, data)
+    end
+    
+    def self.sample(name, val, data = {})
+      librato_log("sample", name, val, data)
+    end
+    
+    def self.stringify(data)
+      data.reduce(out=String.new) do |s, tup|
+        s << [tup.first, tup.last].join("=") << " "
+      end
+    end
+  end
+  
+end

data/lib/koa/measurement.rb

@@ -0,0 +1,45 @@
+module Koa
+  module Measurement
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def measure_methods(*args)
+        @methods_to_measure ||= []
+        @methods_to_measure += args
+        @methods_to_measure.map!(&:to_sym)
+      end
+
+      def method_added(name)
+        return if @adding_measurers
+        @adding_measurers = true
+        if @methods_to_measure.include? name.to_sym
+          unmeasured_name = "unmeasured_#{name}"
+          alias_method unmeasured_name, name
+          define_method name do |*args, &block|
+            Koa::Logger.measure_block(name.to_s.gsub(/_/,"-")) do
+              send unmeasured_name, *args, &block
+            end
+          end
+        end
+        @adding_measurers = nil
+      end
+
+      def singleton_method_added(name)
+        return if @adding_measurers
+        @adding_measurers = true
+        if @methods_to_measure.include? name.to_sym
+          unmeasured_name = "unmeasured_#{name}"
+          self.singleton_class.send(:alias_method, unmeasured_name, name)
+          define_singleton_method name do |*args, &block|
+            Koa::Logger.measure_block(name.to_s.gsub(/_/,"-")) do
+              send unmeasured_name, *args, &block
+            end
+          end
+        end
+        @adding_measurers = nil
+      end
+    end
+  end
+end

data/lib/koa/query-time.rb

@@ -0,0 +1,14 @@
+module Koa
+  module QueryTime
+    def self.enable_log
+      if Rails.env.production?
+        ActiveSupport::Notifications.subscribe "sql.active_record" do |name, start, finish, id, payload|
+          if payload[:name] == "SQL"
+            duration = (finish - start) * 1000
+            Koa::Logger.measure("pg.query", duration.round.to_s+"ms")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/koa/rack-request-timer.rb

@@ -0,0 +1,13 @@
+class Koa::RackRequestTimer
+  def initialize(app)
+    @app = app
+  end
+ 
+  def call(env)
+    start_request = Time.now
+    status, headers, body = @app.call(env)
+    elapsed = (Time.now - start_request) * 1000
+    $stdout.puts("request-id=#{env['HTTP_HEROKU_REQUEST_ID']} measure#rack-request=#{elapsed.round}ms")
+    [status, headers, body]
+  end
+end

data/lib/koa/request.rb

@@ -0,0 +1,106 @@
+require 'cgi'
+require 'delegate'
+require 'json'
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+module Koa
+  class TimeoutResponse
+
+    def successful?
+      false
+    end
+
+    def code
+      '0'
+    end
+
+    def self.body_permitted?
+      false
+    end
+
+    def body
+      nil
+    end
+  end
+
+  class ResponseDecorator < SimpleDelegator
+    def successful?
+      code.to_i / 100 == 2
+    end
+  end
+
+  module Request
+    def self.make(opts)
+      opts[:tries] ||= 1
+      opts[:timeout] ||= 10
+
+      opts[:url] = build_url(opts)
+      opts[:body] = build_body(opts)
+
+      execute(opts)
+    end
+
+    private
+
+    def self.execute(opts)
+      opts[:tries].times do
+
+        begin
+          ::Timeout::timeout(opts[:timeout]) do
+            return ResponseDecorator.new(net_request(opts))
+          end
+        rescue ::Timeout::Error
+        end
+
+      end
+      Koa::TimeoutResponse.new
+    end
+
+    def self.net_request(opts)
+      uri = ::URI.parse(opts[:url])
+      http = ::Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      request = request_factory(opts[:type]).new(uri.request_uri)
+
+      request.basic_auth uri.user, uri.password if uri.user
+      request.basic_auth opts[:auth][:user], opts[:auth][:pass] if opts[:auth]
+
+      if opts[:type] == :post || opts[:type] == :put
+        request.add_field('Content-Type', 'application/json')
+        request.add_field('Content-Length', opts[:body].size)
+        request.body = opts[:body]
+      end
+
+      http.request(request)
+    end
+
+    def self.request_factory(type)
+      return ::Net::HTTP::Post if type == :post
+      return ::Net::HTTP::Put if type == :put
+      return ::Net::HTTP::Delete if type == :delete
+      return ::Net::HTTP::Get if type == :get
+    end
+
+    def self.build_body(opts)
+      body = ""
+      if opts[:type] == :post || opts[:type] == :put
+        body = ::JSON.dump(opts[:data]) if opts[:data]
+      end
+      body
+    end
+
+    def self.build_url(opts)
+      url = opts[:url]
+      if opts[:type] == :get || opts[:type] == :delete
+        url += "?"+hash_to_query(opts[:data]) if opts[:data]
+      end
+      url
+    end
+
+    def self.hash_to_query(hash)
+      hash.map{|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join("&")
+    end
+  end
+end

data/lib/koa/sequel-logger.rb

@@ -0,0 +1,33 @@
+module Koa
+  if defined?(::Sequel)
+      module ::Sequel
+        class Database
+          def log_yield(sql, args=nil)
+            sql = "#{sql}; #{args.inspect}" if args
+            t0 = Time.now
+            begin
+              yield
+            rescue => e
+              log_exception(e, sql)
+              raise
+            ensure
+              t1 = Time.now
+              log_duration(Integer((t1-t0)*1000), sql) unless e
+            end
+          end
+  
+          def log_duration(t, sql)
+            Logger.measure("sequel-latency", t, source: action(sql))
+          end
+  
+          def log_exception(e, sql)
+            Logger.log(error: "sequel-exception", class: e.class)
+          end
+  
+          def action(sql)
+            sql[/(\w+){1}/].downcase
+          end
+        end
+      end
+    end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: koa
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eric Rykwalder
+- Ryan Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Gem of tools for Koala
+email: eric@koa.la
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/koa/conf.rb
+- lib/koa/health-check.rb
+- lib/koa/kik.rb
+- lib/koa/leaderboard-client.rb
+- lib/koa/logger.rb
+- lib/koa/measurement.rb
+- lib/koa/query-time.rb
+- lib/koa/rack-request-timer.rb
+- lib/koa/request.rb
+- lib/koa/sequel-logger.rb
+- lib/koa.rb
+homepage: http://koa.la
+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.0.6
+signing_key: 
+specification_version: 4
+summary: KOA tools
+test_files: []