trakerr_client 1.0.0r

data/trakerr/lib/event_trace_builder.rb

@@ -0,0 +1,163 @@
+require "trakerr_client"
+
+
+module Trakerr
+  class EventTraceBuilder
+
+    ##
+    #Gets the stactrace from the exception instance passed in.
+    #RETURNS: A Stacktrace object that contains the trace of the exception passed in.
+    #exc:Exception: The exception caught or rescued.
+    ##
+    def self.get_stacktrace(exc)
+      raise ArgumentError, "get_stacktrace expects an exception instance." unless exc.is_a? Exception
+
+      strace = Trakerr::Stacktrace.new
+      add_stack_trace(strace, exc)
+      return strace
+    end
+
+    private
+
+      ##
+      #Adds a InnerStackTrace to the Stacktrace object (which is a collection)
+      #strace:Stacktrace: The Stacktrace object to append the latest InnerStackTrace to.
+      #exc:Exception: The exception caught or rescued.
+      ##
+      def self.add_stack_trace(strace, exc)
+        raise ArgumentError, "add_stack_trace did not get passed in the correct arguments" unless exc.is_a? Exception and strace.instance_of? Stacktrace
+
+        newtrace = Trakerr::InnerStackTrace.new
+
+        newtrace.type = exc.class.name
+        newtrace.message = exc.message
+        newtrace.trace_lines = get_event_tracelines(best_regexp_for(exc), exc.backtrace)
+        strace.push(newtrace)
+      end
+
+      ##
+      #Formats and returns a StackTraceLines object that holds the current stacktrace from the error.
+      #RETURNS: A StackTraceLines object that contains the parsed traceback.
+      #regex:RegularExpression: The regular expression to parse the stacktrace text with.
+      #errarray:String[]: An array of strings which each of which is a StackTrace string line.
+      ##
+      def self.get_event_tracelines(regex, errarray)
+        raise ArgumentError, "errarray should be an iterable object." unless errarray.respond_to?('each')
+
+        stlines = Trakerr::StackTraceLines.new
+
+        errarray.each {|line| 
+        stline = Trakerr::StackTraceLine.new
+        match = parse_stacktrace(regex, line)
+        stline.file, stline.line, stline.function = match[:file], match[:line], match[:function]
+
+        stlines.push(stline)
+        }
+        return stlines
+      end
+
+      ##
+      #Parses each given line by the regex
+      #RETURNS: A match object with the capture groups file function and line set.
+      #regex:RegularExpression: The regular expression to parse the stacktrace text with.
+      #line:String: A string with the traceline to parce
+      ##
+      def self.parse_stacktrace(regex, line)
+        raise ArgumentError, "line should be a string." unless line.is_a? String
+
+        match = regex.match(line)
+        return match if match
+
+        raise RegexpError, "line does not fit any of the supported stacktraces." #TODO: Error handle this?
+      end
+
+      def self.best_regexp_for(exc)
+        #add error check
+        if defined?(Java::JavaLang::Throwable) && exc.is_a?(Java::JavaLang::Throwable)
+         @@JAVA
+        elsif defined?(OCIError) && exc.is_a?(OCIError)
+          @@OCI
+        #elsif execjs_exception?(exception)
+          # Patterns::EXECJS disabled pending more complex test
+        else
+          @@RUBY
+        end
+      end
+
+      ##
+      # @return [Regexp] the pattern that matches standard Ruby stack frames,
+      #   such as ./spec/notice_spec.rb:43:in `block (3 levels) in <top (required)>'
+      @@RUBY = %r{\A
+          (?<file>.+)       # Matches './spec/notice_spec.rb'
+          :
+          (?<line>\d+)      # Matches '43'
+          :in\s
+          `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
+        \z}x
+
+      ##
+      # @return [Regexp] the pattern that matches JRuby Java stack frames, such
+      #  as org.jruby.ast.NewlineNode.interpret(NewlineNode.java:105)
+      @@JAVA = %r{\A
+        (?<function>.+)  # Matches 'org.jruby.ast.NewlineNode.interpret'
+        \(
+          (?<file>
+            (?:uri:classloader:/.+(?=:)) # Matches '/META-INF/jruby.home/protocol.rb'
+            |
+            (?:uri_3a_classloader_3a_.+(?=:)) # Matches 'uri_3a_classloader_3a_/gems/...'
+            |
+            [^:]+        # Matches 'NewlineNode.java'
+          )
+          :?
+          (?<line>\d+)?  # Matches '105'
+        \)
+      \z}x
+
+      ##
+      # @return [Regexp] the pattern that tries to assume what a generic stack
+      #   frame might look like, when exception's backtrace is set manually.
+      @@GENERIC = %r{\A
+        (?:from\s)?
+        (?<file>.+)              # Matches '/foo/bar/baz.ext'
+        :
+        (?<line>\d+)?            # Matches '43' or nothing
+        (?:
+          in\s`(?<function>.+)'  # Matches "in `func'"
+        |
+          :in\s(?<function>.+)   # Matches ":in func"
+        )?                       # ... or nothing
+      \z}x
+
+      ##
+      # @return [Regexp] the pattern that matches exceptions from PL/SQL such as
+      #   ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945
+      # @note This is raised by https://github.com/kubo/ruby-oci8
+      @@OCI = /\A
+        (?:
+          ORA-\d{5}
+          :\sat\s
+          (?:"(?<function>.+)",\s)?
+          line\s(?<line>\d+)
+        |
+          #{@@GENERIC}
+        )
+      \z/x
+
+      ##
+      # @return [Regexp] the pattern that matches CoffeeScript backtraces
+      #   usually coming from Rails & ExecJS
+      @@EXECJS = /\A
+        (?:
+          # Matches 'compile ((execjs):6692:19)'
+          (?<function>.+)\s\((?<file>.+):(?<line>\d+):\d+\)
+        |
+          # Matches 'bootstrap_node.js:467:3'
+          (?<file>.+):(?<line>\d+):\d+(?<function>)
+        |
+          # Matches the Ruby part of the backtrace
+          #{@@RUBY}
+        )
+      \z/x
+
+  end
+end

data/trakerr/lib/trakerr.rb

@@ -0,0 +1,235 @@
+require "event_trace_builder"
+require "trakerr_client"
+require "socket"
+require "date"
+
+module Trakerr
+  class TrakerrClient
+
+    ##API Key
+    attr_accessor :apiKey
+
+    ##App Version of the client the API is tying into.
+    attr_accessor :contextAppVersion
+
+    ##Deployment stage of the codebade the API is tying into.
+    attr_accessor :contextDeploymentStage
+
+    ##String name of the language being used.
+    attr_accessor :contextEnvLanguage
+
+    ##The name of the interpreter
+    attr_accessor :contextEnvName
+
+    ## ContextEnvVersion is the version of the interpreter the program is run on.
+    attr_accessor :contextEnvVersion
+
+    ## ContextEnvHostname is hostname of the pc running the code.
+    attr_accessor :contextEnvHostname
+
+    ## ContextAppOS is the OS the program is running on.
+    attr_accessor :contextAppOS
+
+    ## ContextAppOSVersion is the version of the OS the code is running on.
+    attr_accessor :contextAppOSVersion
+
+    ## contextAppBrowser is optional MVC and ASP.net applications the browser name the application is running on.
+    attr_accessor :contextAppBrowser
+
+    ## contextAppBrowserVersion is optional for MVC and ASP.net applications the browser version the application is running on.
+    attr_accessor :contextAppBrowserVersion
+
+    ## ContextDatacenter is the optional datacenter the code may be running on.
+    attr_accessor :contextDataCenter
+
+    ## ContextDatacenterRegion is the optional datacenter region the code may be running on.
+    attr_accessor :contextDataCenterRegion
+
+    ##
+    #Initializes the TrakerrClient class.
+    #apiKey:String: Should be your API key string.
+    #contextAppVersion:String: Should be the version of your application.
+    #contextEnvName:String: Should be the deployment stage of your program.
+    ##
+    def initialize(apiKey,
+                   contextAppVersion = "1.0",
+                   contextDeploymentStage = "development")
+
+      default_config = Trakerr::Configuration.default
+      default_config.base_path = default_config.base_path
+
+      @apiKey = apiKey
+      @contextAppVersion = contextAppVersion
+      @contextDeploymentStage = contextDeploymentStage
+
+      @contextEnvLanguage = "Ruby"
+      
+      if RUBY_PLATFORM == "java"
+        @contextEnvName = "jruby"
+        @contextEnvVersion = JRUBY_VERSION
+      else
+        @contextEnvName = "ruby"
+        @contextEnvVersion = RUBY_VERSION
+      end
+
+      @contextEnvHostname = Socket.gethostname
+        
+      host_os = RbConfig::CONFIG['host_os']
+      case host_os
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          text = `systeminfo`
+
+          @contextAppOS = GetTextFromLine(text, "OS Name:", "\n")
+          @contextAppOS.chomp! if @contextAppOS != nil
+          @contextAppOS.strip! if @contextAppOS != nil
+
+				  version = GetTextFromLine(text, "OS Version:", "\n").split
+          version[0].chomp! if version != nil
+          version[0].strip! if version != nil
+          @contextAppOSVersion = contextAppOSVersion || version[0]
+
+            
+        when /darwin|mac os/
+          text = `system_profiler SPSoftwareDataType`
+
+          @contextAppOS = GetTextFromLine(text, "System Version:", "(").chomp.strip
+				  @contextAppOSVersion = contextAppOSVersion || GetTextFromLine(text, "Kernel Version:", "\n").chomp.strip
+            
+        when /linux/, /solaris|bsd/
+          #uname -s and -r
+          @contextAppOS = `uname -s`.chomp.strip
+          @contextAppOSVersion = contextAppOSVersion || `uname -r`.chomp.strip
+      end
+
+      if @contextAppOS == nil 
+        @contextAppOS = RbConfig::CONFIG["target_os"]
+      end
+      if @contextAppOSVersion == nil
+        @contextAppOSVersion = RbConfig::CONFIG['host_os']
+      end
+      
+      @contextAppBrowser = contextAppBrowser
+      @contextAppBrowserVersion = contextAppBrowserVersion
+      @contextDataCenter = contextDataCenter
+      @contextDataCenterRegion = contextDataCenterRegion
+      api_client = Trakerr::ApiClient.new(default_config)
+      @events_api = Trakerr::EventsApi.new(api_client)
+    end
+
+    ##
+    #Creates a new AppEvent and returns it with a stacktrace if err is an exception object.
+    #If passed false, it returns an AppEvent without a stacktrace.
+    #RETURNS: An AppEvent instance with the default event information.
+    #err:Exception: The exception that is captured or rescued, or false if you don't need a stacktrace.
+    #log_level:String: Logging level, currently one of 'debug','info','warning','error', 'fatal', defaults to 'error'. See loglevel in AppEvent for an always current list of values.
+    #Will argument error if passed another value.
+    #classification:String: Optional extra descriptor string. Will default to issue if not passed a value.
+    #eventType:string: String representation of the type of error.
+    #Defaults to err.class.name if err is an exception, unknown if not.
+    #eventMessage:String: String representation of the message of the error.
+    #Defaults to err.message if err is an exception, unknown if not.
+    ##
+    def CreateAppEvent(err, log_level="Error", classification = "issue", eventType = "unknown", eventMessage = "unknown")
+      raise ArgumentError, "All non err arguments are expected strings." unless log_level.is_a? String and classification.is_a? String and eventType is_a? String and eventMessage.is_a? String
+      if err != false
+        raise ArgumentError, "err is expected instance of exception." unless err.is_a? Exception
+
+        if eventType == nil || eventType == "unknown"
+          eventType = err.class.name
+        end
+
+        if eventMessage == nil || eventMessage == "unknown"
+          eventMessage = err.message
+        end
+
+      end
+
+      log_level = log_level.downcase
+
+      app_event_new = AppEvent.new({classification: classification, eventType: eventType, eventMessage: eventMessage})
+
+      begin
+        app_event_new.log_level = log_level
+      rescue
+        app_event_new.log_level = "error"
+      end
+      
+      app_event_new.event_stacktrace = EventTraceBuilder.get_stacktrace(err) if err != false
+
+      return app_event_new
+    end
+
+    ##
+    #Sends the given AppEvent to Trakerr
+    #appEvent:AppEvent: The AppEvent to send.
+    ##
+    def SendEvent(appEvent)
+      @events_api.events_post(FillDefaults(appEvent))
+    end
+
+    ##
+    #Sends the given error to Trakerr. Simplest use case for Trakerr in a catch, uses the default values when sending.
+    #You can provide an optional log_level or classification.
+    #error:Exception: The exception that is captured or rescued.
+    #log_level:String: Logging level, currently one of 'debug','info','warning','error', 'fatal', defaults to 'error'. See loglevel in AppEvent for an always current list of values.
+    #classification:String: Optional extra descriptor string. Will default to issue if not passed a value.
+    ##
+    def SendException(error, log_level = "error", classification = "issue")
+      raise ArgumentError, "Error is expected type exception." unless error.is_a? Exception
+      raise ArgumentError, "log_level and classification are expected strings" unless log_level.is_a? String and classification.is_a? String
+      
+      SendEvent(CreateAppEvent(Error, log_level, classification))
+    end
+
+    ##
+    #Populates the given AppEvent with the client level default values
+    #RETURNS: The AppEvent with Defaults filled.
+    #appEvent:AppEvent: The AppEvent to fill.
+    ##
+    def FillDefaults(appEvent)
+      appEvent.api_key = appEvent.api_key || @apiKey
+
+      appEvent.context_app_version = appEvent.context_app_version || @contextAppVersion
+      appEvent.deployment_stage = appEvent.deployment_stage || @contextDeploymentStage
+
+      appEvent.context_env_language = appEvent.context_env_language || @contextEnvLanguage
+      appEvent.context_env_name = appEvent.context_env_name || @contextEnvName
+      appEvent.context_env_version = appEvent.context_env_version || @contextEnvVersion
+      appEvent.context_env_hostname = appEvent.context_env_hostname || @contextEnvHostname
+
+      appEvent.context_app_os = appEvent.context_app_os || @contextAppOS
+      appEvent.context_app_os_version = appEvent.context_app_os_version || @contextAppOSVersion
+
+      appEvent.context_app_browser = appEvent.context_app_browser || @contextAppBrowser
+      appEvent.context_app_browser_version = appEvent.context_app_browser_version || @contextAppBrowserVersion
+
+      appEvent.context_data_center = appEvent.context_data_center || @contextDataCenter
+      appEvent.context_data_center_region = appEvent.context_data_center_region || @contextDataCenterRegion
+
+      appEvent.event_time = DateTime.now.strftime("%Q").to_i
+      return appEvent
+    end
+
+    private
+      ##
+      #Used for parsing large strings. Gets the text in between a prefix string and a suffix string.
+      #Currently used to parse responses from shell commands on OS.
+      #RETURNS: The String from text between prefix and suffix or nil if not found or errors occur.
+      #text:String: The text to search in.
+      #prefix:String: The prefix string to start getting the text after
+      #suffix:String: The suffix string to find the ending index for.
+      ##
+      def GetTextFromLine(text, prefix, suffix)
+        raise ArgumentError, "All arguments are expected strings." unless text.is_a? String and prefix.is_a? String and suffix.is_a? String
+      
+        prefixindex = text.index(prefix)
+        return nil if prefixindex == nil
+        prefixindex = prefixindex + prefix.length
+
+        suffixindex = text.index(suffix, prefixindex)
+        return nil if suffixindex == nil
+
+        text[prefixindex...suffixindex]
+      end
+  end
+end

data/trakerr_client.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+#
+=begin
+#Trakerr API
+
+#Get your application events and errors to Trakerr via the *Trakerr API*.
+
+OpenAPI spec version: 1.0.0
+
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+
+Licensed 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.
+
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path("../generated/lib", __FILE__)
+$:.push File.expand_path("../trakerr/lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "trakerr_client"
+  s.version     = "1.0.0r"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Swagger-Codegen"]
+  s.email       = [""]
+  s.homepage    = "https://github.com/swagger-api/swagger-codegen"
+  s.summary     = "Trakerr API Ruby Gem"
+  s.description = "Get your application events and errors to Trakerr via the *Trakerr API*."
+  s.license     = "Apache-2.0"
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1'
+  s.add_runtime_dependency 'json', '~> 1.8', '>= 1.8.3'
+
+  s.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
+  s.add_development_dependency 'vcr', '~> 3.0', '>= 3.0.1'
+  s.add_development_dependency 'webmock', '~> 1.24', '>= 1.24.3'
+  s.add_development_dependency 'autotest', '~> 4.4', '>= 4.4.6'
+  s.add_development_dependency 'autotest-rails-pure', '~> 4.1', '>= 4.1.2'
+  s.add_development_dependency 'autotest-growl', '~> 0.2', '>= 0.2.16'
+  s.add_development_dependency 'autotest-fsevent', '~> 0.2', '>= 0.2.11'
+
+  #s.files         = `find *`.split("\n").uniq.sort.select{|f| !f.empty? }
+  s.files         = `git ls-files`.split("\n").delete_if {|file| file.include? "spec"}
+  s.test_files    = `git ls-files`.split("\n").delete_if {|file| not file.include? "spec"}
+  s.executables   = []
+  s.require_paths = ["generated/lib", "trakerr/lib"]
+end