skylight-core 2.0.0.beta1

data/lib/skylight/core/util/clock.rb

@@ -0,0 +1,56 @@
+module Skylight::Core
+  module Util
+    # A more precise clock
+    class Clock
+
+      def self.use_native!
+        class_eval do
+          def tick
+            native_hrtime
+          end
+        end
+      end
+
+      def tick
+        now = Time.now
+        now.to_i * 1_000_000_000 + now.usec * 1_000
+      end
+
+      # TODO: rename to secs
+      def absolute_secs
+        Time.now.to_i
+      end
+
+      # TODO: remove
+      def nanos
+        tick
+      end
+
+      # TODO: remove
+      def secs
+        nanos / 1_000_000_000
+      end
+
+      def self.absolute_secs
+        default.absolute_secs
+      end
+
+      def self.nanos
+        default.nanos
+      end
+
+      def self.secs
+        default.secs
+      end
+
+      def self.default
+        @clock ||= Clock.new
+      end
+
+      def self.default=(clock)
+        @clock = clock
+      end
+
+    end
+  end
+end

data/lib/skylight/core/util/deploy.rb

@@ -0,0 +1,132 @@
+require 'json'
+require 'uri'
+require 'skylight/core/util/logging'
+
+module Skylight::Core
+  module Util
+
+    module Deploy
+
+      def self.build(config)
+        DEPLOY_TYPES.each do |type|
+          deploy = type.new(config)
+          return deploy if deploy.id
+        end
+        nil
+      end
+
+      class EmptyDeploy
+
+        attr_reader :config
+        attr_reader :timestamp
+
+        def initialize(config)
+          @config = config
+          @timestamp = Time.now.to_i
+        end
+
+        def id
+          git_sha
+        end
+
+        def git_sha
+          nil
+        end
+
+        def description
+          nil
+        end
+
+        def to_query_string
+          URI.encode_www_form(
+            timestamp:   timestamp,
+            deploy_id:   id.to_s[0..100], # Keep this sane
+            git_sha:     git_sha ? git_sha[0..40] : nil, # A valid SHA will never exceed 40
+            description: description ? description[0..255] : nil) # Avoid massive descriptions
+        end
+
+      end
+
+      class DefaultDeploy < EmptyDeploy
+        include Logging
+
+        def initialize(*)
+          super
+          if description && !id
+            warn "The configured deploy will be ignored as an id or git_sha must be provided."
+          end
+        end
+
+        def id
+          config.get(:'deploy.id') || git_sha
+        end
+
+        def git_sha
+          config.get(:'deploy.git_sha')
+        end
+
+        def description
+          config.get(:'deploy.description')
+        end
+
+      end
+
+      class HerokuDeploy < EmptyDeploy
+
+        def initialize(*)
+          super
+          @info = get_info
+        end
+
+        def id
+          @info ? @info['id'] : nil
+        end
+
+        def git_sha
+          @info ? @info['commit'] : nil
+        end
+
+        def description
+          @info ? @info['description'] : nil
+        end
+
+        private
+
+          def get_info
+            info_path = config[:'heroku.dyno_info_path']
+
+            if File.exist?(info_path)
+              if info = JSON.parse(File.read(info_path))
+                info['release']
+              end
+            end
+          end
+
+      end
+
+      class GitDeploy < EmptyDeploy
+
+        attr_reader :git_sha, :description
+
+        def initialize(*)
+          super
+          @git_sha, @description = get_info
+        end
+
+        private
+
+          def get_info
+            Dir.chdir(config.root) do
+              info = `git log -1 --pretty="%H %s" 2>&1`
+              info.split(" ", 2).map(&:strip) if $?.success?
+            end
+          end
+
+      end
+
+      DEPLOY_TYPES = [DefaultDeploy, HerokuDeploy, GitDeploy]
+
+    end
+
+  end
+end

data/lib/skylight/core/util/gzip.rb

@@ -0,0 +1,21 @@
+require 'zlib'
+
+module Skylight::Core
+  module Util
+    # Provides Gzip compressing support
+    module Gzip
+
+      # Compress a string with Gzip
+      #
+      # @param str [String] uncompressed string
+      # @return [String] compressed string
+      def self.compress(str)
+        output = StringIO.new
+        gz = Zlib::GzipWriter.new(output)
+        gz.write(str)
+        gz.close
+        output.string
+      end
+    end
+  end
+end

data/lib/skylight/core/util/inflector.rb

@@ -0,0 +1,112 @@
+module Skylight::Core
+  module Util
+
+    # String Inflector methods
+    #
+    # From https://github.com/rails/rails/blob/f8e5022c73679f41db9bb6743179bab4571fb28e/activesupport/lib/active_support/inflector/methods.rb
+    module Inflector
+      extend self
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   'Module'.constantize     # => Module
+      #   'Test::Unit'.constantize # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C               # => 'inside'
+      #     'C'.constantize # => 'outside', same as ::C
+      #   end
+      #
+      # NameError is raised when the name is not in CamelCase or the constant is
+      # unknown.
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+
+        # Trigger a builtin NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check it it's owned
+            # directly before we reach Object or the end of ancestors.
+            constant = constant.ancestors.inject do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   'Module'.safe_constantize     # => Module
+      #   'Test::Unit'.safe_constantize # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                    # => 'inside'
+      #     'C'.safe_constantize # => 'outside', same as ::C
+      #   end
+      #
+      # +nil+ is returned when the name is not in CamelCase or the constant (or
+      # part of it) is unknown.
+      #
+      #   'blargle'.safe_constantize  # => nil
+      #   'UnknownModule'.safe_constantize  # => nil
+      #   'UnknownModule::Foo::Bar'.safe_constantize  # => nil
+      def safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+          e.name.to_s == camel_cased_word.to_s
+      rescue ArgumentError => e
+        raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+      end
+
+      private
+
+      # Mount a regular expression that will match part by part of the constant.
+      #
+      #   const_regexp("Foo::Bar::Baz") # => /(Foo(::Bar(::Baz)?)?|Bar|Baz)/
+      #   const_regexp("::")            # => /::/
+      #
+      # NOTE: We also add each part in singly, because sometimes a search for a missing
+      # constant like Skylight::Foo::Bar will return an error just saying Foo was missing
+      def const_regexp(camel_cased_word) #:nodoc:
+        parts = camel_cased_word.split("::")
+
+        return Regexp.escape(camel_cased_word) if parts.empty?
+
+        regexp = parts.reverse.inject do |acc, part|
+          part.empty? ? acc : "#{part}(::#{acc})?"
+        end
+
+        "(" + ([regexp] + parts[1..-1]).join('|') + ")"
+      end
+    end
+  end
+end

data/lib/skylight/core/util/logging.rb

@@ -0,0 +1,127 @@
+require 'logger'
+
+module Skylight::Core
+  module Util
+    # Log both to the specified logger and STDOUT
+    class AlertLogger
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def write(*args)
+        STDERR.write *args
+
+        # Try to avoid writing to STDOUT/STDERR twice
+        logger_logdev = @logger.instance_variable_get(:@logdev)
+        logger_out = logger_logdev && logger_logdev.respond_to?(:dev) ? logger_logdev.dev : nil
+        if logger_out != STDOUT && logger_out != STDERR
+          @logger.<<(*args)
+        end
+      end
+
+      def close
+      end
+    end
+
+    module Logging
+
+      def self.trace?
+        ENV[Skylight::TRACE_ENV_KEY]
+      end
+
+      if trace?
+        # The second set is picked up by YARD
+        def trace(msg, *args)
+          log :debug, msg, *args
+        end
+
+        def t
+          log :debug, yield
+        end
+      else
+        # Logs if `ENV[TRACE_ENV_KEY]` is set.
+        #
+        # @param (see #debug)
+        #
+        # See {TRACE_ENV_KEY}.
+        def trace(msg, *args)
+        end
+
+        # Evaluates and logs the result of the block if `ENV[TRACE_ENV_KEY]` is set
+        #
+        # @yield block to be evaluted
+        # @yieldreturn arguments for {#debug}
+        #
+        # See {TRACE_ENV_KEY}.
+        def t
+        end
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def debug(msg, *args)
+        log :debug, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def info(msg, *args)
+        log :info, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def warn(msg, *args)
+        log :warn, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def error(msg, *args)
+        log :error, msg, *args
+        raise sprintf(msg, *args) if ENV['SKYLIGHT_RAISE_ON_ERROR']
+      end
+
+      alias log_trace trace
+      alias log_debug debug
+      alias log_info  info
+      alias log_warn  warn
+      alias log_error error
+
+      # Alias for `Kernel#sprintf`
+      # @return [String]
+      def fmt(*args)
+        sprintf(*args)
+      end
+
+      # @param level [String,Symbol] the method on `logger` to use for logging
+      # @param msg [String] the message to log
+      # @param args [Array] values for `Kernel#sprintf` on `msg`
+      def log(level, msg, *args)
+        c = if respond_to?(:config)
+          config
+        elsif self.is_a?(Config)
+          self
+        end
+
+        return unless c
+
+        if logger = c.logger
+          return unless logger.respond_to?(level)
+
+          if args.length > 0
+            logger.send level, sprintf("[SKYLIGHT] [#{Skylight::Core::VERSION}] #{msg}", *args)
+          else
+            logger.send level, "[SKYLIGHT] [#{Skylight::Core::VERSION}] #{msg}"
+          end
+        end
+      rescue Exception => e
+        if ENV[Skylight::TRACE_ENV_KEY]
+          puts "[ERROR] #{e.message}"
+          puts e.backtrace
+        end
+      end
+
+    end
+  end
+end

data/lib/skylight/core/util/platform.rb

@@ -0,0 +1,77 @@
+require 'rbconfig'
+
+# Used from extconf and to load libskylight
+module Skylight
+  module Core
+    module Util
+      module Platform
+        # Normalize the platform OS
+        OS = case os = RbConfig::CONFIG['host_os'].downcase
+        when /linux/
+          # The official ruby-alpine Docker containers pre-build Ruby. As a result,
+          #   Ruby doesn't know that it's on a musl-based platform. `ldd` is the
+          #   only reliable way to detect musl that we've found.
+          # See https://github.com/skylightio/skylight-ruby/issues/92
+          if ENV['SKYLIGHT_MUSL'] || `ldd --version 2>&1` =~ /musl/
+            "linux-musl"
+          else
+            "linux"
+          end
+        when /darwin/
+          "darwin"
+        when /freebsd/
+          "freebsd"
+        when /netbsd/
+          "netbsd"
+        when /openbsd/
+          "openbsd"
+        when /sunos|solaris/
+          "solaris"
+        when /mingw|mswin/
+          "windows"
+        else
+          os
+        end
+
+        # Normalize the platform CPU
+        ARCH = case cpu = RbConfig::CONFIG['host_cpu'].downcase
+        when /amd64|x86_64/
+          "x86_64"
+        when /i?86|x86|i86pc/
+          "x86"
+        when /ppc|powerpc/
+          "powerpc"
+        when /^arm/
+          "arm"
+        else
+          cpu
+        end
+
+        LIBEXT = case OS
+        when /darwin/
+          'dylib'
+        when /linux|bsd|solaris/
+          'so'
+        when /windows|cygwin/
+          'dll'
+        else
+          'so'
+        end
+
+        TUPLE = "#{ARCH}-#{OS}"
+
+        def self.tuple
+          TUPLE
+        end
+
+        def self.libext
+          LIBEXT
+        end
+
+        def self.dlext
+          RbConfig::CONFIG['DLEXT']
+        end
+      end
+    end
+  end
+end

data/lib/skylight/core/util/proxy.rb

@@ -0,0 +1,13 @@
+module Skylight::Core
+  module Util
+    module Proxy
+      def self.detect_url(env)
+        u = env['HTTP_PROXY'] || env['http_proxy']
+        if u && !u.empty?
+          u = "http://#{u}" unless u =~ %r[://]
+          u
+        end
+      end
+    end
+  end
+end

data/lib/skylight/core/util.rb

@@ -0,0 +1,14 @@
+module Skylight::Core
+  # @api private
+  module Util
+    # Used from the main lib
+    require 'skylight/core/util/allocation_free'
+    require 'skylight/core/util/clock'
+    require 'skylight/core/util/deploy'
+    require 'skylight/core/util/logging'
+
+    # Used from the CLI
+    autoload :Gzip,      'skylight/core/util/gzip'
+    autoload :Inflector, 'skylight/core/util/inflector'
+  end
+end