skywalking 0.0.0.alpha → 0.0.0.beta2

data/lib/rails/generators/skywalking/start_generator.rb

@@ -0,0 +1,47 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Skywalking
+  class StartGenerator < ::Rails::Generators::Base
+    source_root File.join(File.dirname(__FILE__), 'templates')
+    desc 'Creates a skywalking initializer'
+
+    @namespace = "skywalking:start"
+
+    def copy_initializer
+      print_header
+      print_footer
+
+      template "skywalking_initializer.rb", "config/initializers/skywalking.rb"
+    end
+
+    private
+
+    def print_header
+      say ""
+      say shell.set_color "Welcome to the SkyWalking Ruby Agent instrumentation setup.", :green, :bold
+      say ""
+    end
+
+    def print_footer
+      say ""
+      say "You can configure skywalking start parameters by modifying config/initializers/skywalking.rb."
+      say ""
+      say "Thanks for using! Welcome to contribute to the SkyWalking community."
+      say ""
+    end
+  end
+end
+

data/{examples/rails-demo/config/initializers/skywalking_ruby.rb → lib/rails/generators/skywalking/templates/skywalking_initializer.rb}

@@ -13,6 +13,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require_relative '../../../../lib/skywalking'
-
 Skywalking.start

data/lib/skywalking/agent.rb

@@ -41,7 +41,9 @@ module Skywalking
           config ||= {}
           config = Configuration.new(config) unless config.is_a?(Configuration)
 
-          @agent = new(config.agent_config).start!
+          @logger = config.logger
+          @agent_config = config.agent_config
+          @agent = new(@agent_config).start!
           config.freeze
         end
       end
@@ -59,12 +61,10 @@ module Skywalking
         !!(defined?(@agent) && @agent)
       end
 
-      def config
-        @config ||= Configuration.new.agent_config
-      end
+      attr_reader :logger, :agent_config
     end
 
-    attr_reader :plugins, :logger, :reporter
+    attr_reader :plugins, :reporter
 
     def initialize(config)
       @plugins = Plugins::PluginsManager.new(config)

data/lib/skywalking/configuration.rb

@@ -29,7 +29,17 @@ module Skywalking
         default: 'Your_InstanceName',
         desc: 'The name of this particular awesome Ruby service instance'
       },
-      :collector_backend_service => {
+      :namespace => {
+        type: :string,
+        default: '',
+        desc: 'The namespace of the service'
+      },
+      :environment => {
+        type: :string,
+        default: '',
+        desc: 'The name of the environment this service is deployed in'
+      },
+      :collector_backend_services => {
         type: :string,
         default: '127.0.0.1:11800',
         desc: 'Backend service addresses'
@@ -37,16 +47,16 @@ module Skywalking
       :config_file => {
         type: :string,
         default: '',
-        desc: 'The path to the config file'
+        desc: 'The absolute path to the configuration file'
       },
-      :log_file => {
+      :log_file_name => {
         type: :string,
-        default: 'skywalking.log',
+        default: 'skywalking',
         desc: 'The name of the log file'
       },
       :log_file_path => {
         type: :string,
-        default: 'STDOUT',
+        default: '',
         desc: 'The path to the log file'
       },
       :log_level => {
@@ -57,7 +67,7 @@ module Skywalking
       :disable_plugins => {
         type: :string,
         default: '',
-        desc: 'The plugins to disable'
+        desc: "The plugins to disable, multiple names should be split by comma, e.g. 'redis5,elasticsearch'"
       },
       :report_protocol => {
         type: :string,
@@ -69,11 +79,6 @@ module Skywalking
         default: '',
         desc: 'Ignore specific URL paths'
       },
-      :namespace => {
-        type: :string,
-        default: '',
-        desc: 'The namespace of the service'
-      },
       :instance_properties_json => {
         type: :string,
         default: '',
@@ -98,19 +103,24 @@ module Skywalking
     }.freeze
 
     # @api private
-    attr_reader :agent_config
+    attr_reader :agent_config, :logger
 
     def initialize(opts = {})
       @agent_config = {}
       initialize_config(opts)
+      if @logger.nil?
+        @logger ||= Mutex.new.synchronize { build_logger }
+      end
     end
 
     def initialize_config(opts)
       # from the default value
       merge_config(DEFAULTS.transform_values { |v| v[:default] })
+      # start parameters
       merge_config(opts)
       # from the custom config file
       merge_config(override_config_by_file)
+      # environment variables
       merge_config(override_config_by_env)
     end
 
@@ -124,10 +134,15 @@ module Skywalking
 
     def override_config_by_file
       config_yaml = @agent_config[:config_file]
-      return if config_yaml.nil? || config_yaml.empty?
+      if config_yaml.nil? || config_yaml.empty?
+        config_yaml = File.join(srv_root, "config", "skywalking.yml")
+      end
 
       unless File.exist?(config_yaml)
-        logger.warn "No config file found at #{config_yaml}"
+        return
+      end
+
+      unless srv_environment
         return
       end
 
@@ -140,10 +155,10 @@ module Skywalking
                       else
                         YAML.safe_load(erb_file, permitted_classes: [], permitted_symbols: [], aliases: true)
                       end
+        loaded_yaml = loaded_yaml[srv_environment]
         error = "Invalid format in config file" if loaded_yaml && !loaded_yaml.is_a?(Hash)
       rescue Exception => e
         error = e.message
-        logger.error "override config by file failed, error=%s", e.message
         nil
       end
       raise StandardError, "Error loading config file: #{config_yaml} - #{error}" if error
@@ -187,14 +202,18 @@ module Skywalking
       self
     end
 
+    def srv_environment
+      @agent_config[:environment].to_s.empty? ? Skywalking::Environment.instance.framework_env : @agent_config[:environment]
+    end
+
+    def srv_root
+      Skywalking::Environment.instance.framework_root
+    end
+
     #####
     # LOAD LOG
     #####
-    def logger
-      @logger ||= Mutex.new.synchronize { get_logger }
-    end
-
-    def get_logger
+    def build_logger
       return @logger if @logger
 
       log_dest = log_destination
@@ -203,17 +222,17 @@ module Skywalking
 
     def create_log(log_dest, level)
       if log_dest.is_a?(String)
-        log_dest = File.expand_path(out, Pathname.new(Dir.pwd).realpath)
+        log_dest = File.expand_path(log_dest, Pathname.new(Dir.pwd).realpath)
         FileUtils.mkdir_p(File.dirname(log_dest))
       end
 
       begin
-        logger = ::Logger.new(log_dest, progname: "Skywalking-Ruby", level: level)
+        logger = ::Logger.new(log_dest, progname: "Skywalking", level: level)
         logger.formatter = log_formatter
 
         logger
       rescue => e
-        logger = ::Logger.new($stdout, progname: "Skywalking-Ruby", level: level)
+        logger = ::Logger.new($stdout, progname: "Skywalking", level: level)
         logger.warn "Create logger for file #{log_dest} failed, using standard out for logging error=#{e.message}"
       end
     end
@@ -226,30 +245,32 @@ module Skywalking
     end
 
     def log_destination
-      if stdout?
+      candidate = @agent_config[:log_file_path].upcase
+
+      case candidate
+      when "STDOUT"
         $stdout
-      elsif !agent_config[:log_file].nil?
-        agent_config[:log_file]
-      elsif !agent_config[:log_file_path].nil?
-        "#{agent_config[:log_file_path]}/skywalking.log"
-      else
+      when "STDERR"
+        $stderr
+      when nil? || ''
         $stdout
+      else
+        "#{@agent_config[:log_file_path]}/#{@agent_config[:log_file_name]}.log"
       end
     end
 
     def get_log_level
-      case @agent_config[:log_level]
+      candidate = @agent_config[:log_level].downcase
+
+      case candidate
       when "debug" then ::Logger::DEBUG
       when "info" then ::Logger::INFO
       when "warn" then ::Logger::WARN
       when "error" then ::Logger::ERROR
       when "fatal" then ::Logger::FATAL
+      when ::Logger::DEBUG, ::Logger::INFO, ::Logger::WARN, ::Logger::ERROR, ::Logger::FATAL then candidate
       else ::Logger::INFO
       end
     end
-
-    def stdout?
-      @agent_config[:log_file_path] == "STDOUT"
-    end
   end
 end

data/lib/skywalking/environment.rb

@@ -20,27 +20,119 @@ module Skywalking
     include Singleton
     include Log::Logging
 
-    def framework_info
-      @framework_info ||= generate_framework_info
+    class RailsFramework
+      def name
+        :rails
+      end
+
+      def present?
+        defined?(::Rails) && defined?(::Rails::VERSION)
+      end
+
+      def app_name
+        if defined?(::Rails)
+          ::Rails.application.class.to_s
+                 .sub(/::Application$/, '')
+        end
+      rescue
+        nil
+      end
+      
+      def env
+        ::Rails.env
+      end
     end
 
-    def generate_framework_info
-      if defined?(::Rails::Application)
-        :rails
-      elsif defined?(::Sinatra::Base)
+    class SinatraFramework
+      def name
         :sinatra
-      else
+      end
+
+      def present?
+        defined?(::Sinatra) && defined?(::Sinatra::Base)
+      end
+
+      def app_name
+        candidate = ObjectSpace.each_object(Class).select { |klass| klass < ::Sinatra::Base } - [::Sinatra::Application]
+
+        if candidate.length == 1
+          candidate.first.name
+        else
+          "Sinatra"
+        end
+      rescue
+        "Sinatra"
+      end
+      
+      def env
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+      end
+    end
+
+    class RubyFramework
+      def name
         :ruby
       end
+
+      def present?
+        true
+      end
+
+      def app_name
+        "Ruby"
+      end
+      
+      def env
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+      end
+    end
+
+    FRAMEWORKS = [
+      RailsFramework.new,
+      SinatraFramework.new,
+      RubyFramework.new
+    ].freeze
+
+    def framework_info
+      @framework ||= FRAMEWORKS.detect { |candidate| candidate.present? }
+    end
+
+    def framework_name
+      @framework_name ||= framework_info.name
+    end
+
+    def framework_root
+      @framework_root ||= case @framework_name
+                          when :rails
+                            ::Rails.root
+                          when :sinatra
+                            Sinatra::Application.root || "."
+                          else
+                            "."
+                          end
     end
     
-    def sinatra?
-      @framework_info = :sinatra
+    def framework_env
+      @framework_env ||= framework_info.env
+    end
+
+    def app_name
+      framework_info.app_name
+    end
+
+    def rails?
+      if defined?(::Rails)
+        ::Rails.application.class.to_s
+               .sub(/::Application$/, '')
+      end
+    rescue
+      nil
     end
 
     def shutdown_handler_supported?
-      if sinatra?
-        info "Shutdown handler not supported for Sinatra"
+      case framework_name
+      when :sinatra
+        warn "Shutdown handler not supported for Sinatra"
         false
       else
         true

data/lib/skywalking/log/logger.rb

@@ -33,7 +33,7 @@ module Skywalking
       end
 
       def log(level, msg, *args)
-        logger = Configuration.new.logger
+        logger = Agent.logger
         if logger
           if logger.respond_to?(level)
             if args.empty?

data/lib/skywalking/plugins/elasticsearch.rb

@@ -0,0 +1,61 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Skywalking
+  module Plugins
+    class Elasticsearch < PluginsManager::SWPlugin
+      def plugin_valid?
+        defined?(::Elasticsearch)
+      end
+
+      def install
+        inst_target = if defined?(::Elastic::Transport::Client)
+                        ::Elastic::Transport::Client
+                      elsif defined?(::Elasticsearch::Transport::Client)
+                        ::Elasticsearch::Transport::Client
+                      end
+
+        inst_target.class_eval do
+          def perform_request_with_skywalking(method, path, *args, &block)
+            peer_info = transport.hosts.first
+            db_statement = [{ params: args&.[](0) }]
+            unless args[1].nil? || args[1].empty?
+              db_statement << { body: args[1] }
+            end
+
+            Tracing::ContextManager.new_exit_span(
+              operation: "Elasticsearch/#{method}/#{path}",
+              peer: "#{peer_info[:protocol]}://#{peer_info[:host]}:#{peer_info[:port]}",
+              component: Tracing::Component::Elasticsearch
+            ) do |span|
+              span&.tag(Tracing::TagDbType.new("Elasticsearch"))
+              span&.tag(Tracing::TagDbStatement.new(db_statement))
+              span&.layer = Tracing::Layer::Database
+
+              zuper_perform_request(method, path, *args, &block)
+            rescue
+              span&.error_occurred = true
+            end
+          end
+
+          alias_method :zuper_perform_request, :perform_request
+          alias_method :perform_request, :perform_request_with_skywalking
+        end
+      end
+
+      register :elasticsearch
+    end
+  end
+end

data/lib/skywalking/plugins/memcached.rb

@@ -0,0 +1,74 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Skywalking
+  module Plugins
+    module MemcachedIntercept
+      def self.included(klass)
+        supported_method =
+          [:add, :append, :delete, :cas, :incr, :increment, :prepend, :replace, :set, :get, :fetch]
+          .select do |method_name|
+            klass.method_defined?(method_name) || klass.private_method_defined?(method_name)
+          end
+
+        supported_method.each do |method_name|
+          zuper_method = :"zuper_#{method_name}"
+          method_with_skywalking = :"#{method_name}_with_skywalking"
+
+          klass.class_eval do
+            define_method(method_with_skywalking) do |*args, &block|
+              cache_key = args[0].to_s if args.length && !args[0].is_a?(Array)
+              Tracing::ContextManager.new_exit_span(
+                operation: "Memcached/#{method_name}",
+                peer: @normalized_servers.join(','),
+                component: Tracing::Component::Memcached
+              ) do |span|
+                span&.layer = Tracing::Layer::Cache
+                span&.tag(Tracing::TagCacheType.new("Memcached"))
+                span&.tag(Tracing::TagCacheKey.new(cache_key))
+
+                resp = __send__(zuper_method, *args, &block)
+                if method_name == :get && args.length && args[0].instance_of?(String)
+                  span&.tag(Tracing::TagCacheMiss.new(resp.nil?))
+                end
+
+                resp
+              rescue
+                span&.error_occurred = true
+              end
+            end
+
+            alias_method zuper_method, method_name
+            alias_method method_name, method_with_skywalking
+          end
+        end
+      end
+    end
+
+    class Memcached < PluginsManager::SWPlugin
+      def plugin_valid?
+        defined?(::Dalli::Client)
+      end
+
+      def install
+        ::Dalli::Client.class_eval do
+          include Skywalking::Plugins::MemcachedIntercept
+        end
+      end
+
+      register :memcached
+    end
+  end
+end

data/lib/skywalking/plugins/net_http.rb

@@ -0,0 +1,73 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module Skywalking
+  module Plugins
+    class NetHttp < PluginsManager::SWPlugin
+      module HttpIntercept
+        def request(req, body = nil, &block)
+          method = req.method
+          host = req['host']&.split(':')&.first || address || 'localhost'
+          req_path = URI(req.path)
+          req_info = ""
+          uri = if req_path.host
+                  req_path
+                else
+                  path, query = req.path.split('?')
+                  scheme = use_ssl? ? 'https' : 'http'
+                  req_info = "#{path}#{query ? "?#{query}" : ''}"
+                  full_url = "#{scheme}://#{host}#{":#{port}" if port}#{req_info}"
+                  URI(full_url)
+                end
+
+          Tracing::ContextManager.new_exit_span(
+            operation: "#{method}:#{req_info}",
+            peer: host,
+            component: Tracing::Component::HttpClient
+          ) do |span|
+            span&.tag(Tracing::TagHttpMethod.new(method))
+            span&.tag(Tracing::TagHttpURL.new(uri))
+            span&.layer = Tracing::Layer::Http
+
+            carrier = span&.inject
+            headers = req.instance_variable_get(:@header)
+            carrier&.each do |item|
+              headers[item.key] ||= []
+              headers[item.key].concat(Array(item.value))
+            end
+
+            result = super(req, body, &block)
+            span&.tag(Tracing::TagHttpStatusCode.new(result.code))
+            if result.code >= "400"
+              span&.error_occurred = true
+            end
+
+            result
+          end
+        end
+      end
+
+      def plugin_valid?
+        defined?(::Net) && defined?(::Net::HTTP)
+      end
+
+      def install
+        ::Net::HTTP.prepend HttpIntercept
+      end
+
+      register :net_http
+    end
+  end
+end

data/lib/skywalking/plugins/redis5.rb

@@ -26,10 +26,15 @@ module Skywalking
             peer: _endpoint_info,
             component: Tracing::Component::Redis
           ) do |span|
-            span&.tag(Tracing::TagDbType.new("Redis"))
-            span&.layer = Tracing.find_mapping(Tracing::Layer, Tracing::Layer::Cache)
+            span&.tag(Tracing::TagCacheType.new("Redis"))
+            span&.tag(Tracing::TagCacheOp.new(operation))
+            span&.layer = Tracing::Layer::Cache
 
-            super(args, &block)
+            begin
+              super(args, &block)
+            rescue
+              span&.error_occurred = true
+            end
           end
         end
 

data/lib/skywalking/plugins/sinatra.rb

@@ -21,21 +21,22 @@ module Skywalking
           req_method = @request.request_method if @request.respond_to?(:request_method)
           carrier = Tracing::Carrier.new
           carrier.each do |item|
-            item.val = request.env[item.key.capitalize] if request.env[item.key.capitalize]
+            item.value = request.env["HTTP_#{item.key.upcase}"]
           end
 
           Tracing::ContextManager.new_entry_span(
-            operation: request.env['REQUEST_URI'].to_s,
-            carrier: carrier,
-            inherit: Tracing::Component::General
+            operation: "#{req_method}:#{request.env['REQUEST_URI']}",
+            carrier: carrier
           ) do |span|
             span&.tag(Tracing::TagHttpMethod.new(req_method))
             span&.tag(Tracing::TagHttpURL.new(request.env['REQUEST_URI']))
-            span&.layer = Tracing.find_mapping(Tracing::Layer, Tracing::Layer::Http)
+            span&.layer = Tracing::Layer::Http
             span&.peer = "#{request.env['SERVER_NAME']}:#{request.env['SERVER_PORT']}"
             span&.component = Tracing::Component::Sinatra
 
             super(*args, &block)
+          rescue
+            span&.error_occurred = true
           end
         end
       end