fyipe 3.0.11516 → 3.0.11910.pre.qa

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c497c9ac737e8c3dc70b4f5793eb388ab5e5a6ec6e431212d7cff2031f201228
-  data.tar.gz: 8ff5fbe0e4d8fe54aec562fe17b96267c2cd88f004b780b8f62bd74109a19be4
+  metadata.gz: 2331d90271eaac762d3a0d6987224401ef1a8a90d34af6435d21bc8d9cc7ad7e
+  data.tar.gz: c431a30d6b080f0c5fa5a3c4cff65506488fd4e155b9d9a51302d41de3e68849
 SHA512:
-  metadata.gz: 04b823df12a09d4f5e95ef3233cc444b31c7572f438601a86d3772aa3e3bc677d826a56ddc1c5aed30189011496307db19b1ca0a734fb25a63369e0d3a180ed4
-  data.tar.gz: 8a9d36d40e4ca6aa4b9a948fd4c71ee7c8bc57811a83d7943002c2fa7ba83725fdd088483d2b597506b48ac97c884b67f7b8382f868c4e2774d1c13543dae125
+  metadata.gz: 7bf055e46779a5af6f0a431d49b3514abf58b4165c38283b6030afa5a833879c12387cb3e824afe0d82448c26139e16ebd2e8e871b5a58b377d14040b2b19cf7
+  data.tar.gz: 4081bc1ac42955010ac7f03259a17376adf5ed7e4f69ed7ae69db9f579cdd5cdec4ad6a25f638855702dc70e0a8496adc598578dac113f27db57d777babd833b

data/.gitignore

@@ -11,4 +11,5 @@ pkg/*
 .DS_Store
 .env
 spec/dummy/tmp/*
-spec/dummy/log/*.log
+spec/dummy/log/*.log
+demo.rb

data/fyipe.gemspec

@@ -2,7 +2,7 @@ require File.expand_path('lib/fyipe/version', __dir__)
 
 Gem::Specification.new do |spec|
 
-    spec.name                  = 'fyipe'
+    spec.name                  = Fyipe::NAME
     spec.version               = Fyipe::VERSION
     spec.authors               = ['HackerBay, Inc.']
     spec.email                 = ['hello@hackerbay.io']
@@ -19,7 +19,8 @@ Gem::Specification.new do |spec|
     spec.files = all_files - test_files
     spec.extra_rdoc_files = ['README.md']
     spec.add_dependency 'httparty', '~> 0.17'
-    spec.add_dependency 'gem-release'
+    spec.add_dependency 'gem-release', '~> 2.2'
+    spec.add_dependency 'ruby-enum', '~> 0.9'
     spec.add_development_dependency 'dotenv', '~> 2.5'
     spec.add_development_dependency 'rspec', '~> 3.6'
     spec.add_development_dependency 'rubocop', '~> 0.60'

data/lib/fyipe/fyipeListener.rb

@@ -0,0 +1,42 @@
+require_relative 'timelineManager'
+require_relative 'util'
+
+class FyipeListener
+    def initialize(eventId, options)
+        # start the timeline manager
+        @timelineObj = FyipeTimelineManager.new(options)
+        @currentEventId = eventId
+        @utilObj = Util.new(options)
+    end
+
+    def logErrorEvent(content, category = 'exception')
+        timelineObj = {}
+        timelineObj["category"]= category
+        timelineObj["data"]= content
+        timelineObj["type"]= @utilObj.getErrorType('ERROR')
+        timelineObj["eventId"]= @currentEventId
+
+        # add timeline to the stack
+        @timelineObj.addToTimeline(timelineObj)
+    end
+
+    def logCustomTimelineEvent(timelineObj)
+        timelineObj["eventId"] = @currentEventId
+
+        # add timeline to the stack
+        @timelineObj.addToTimeline(timelineObj)
+    end
+
+    def getTimeline()
+        # this always get the current state of the timeline array
+        return @timelineObj.getTimeline()
+    end
+
+    def clearTimeline(eventId)
+        # set a new eventId
+        @currentEventId = eventId
+        # this will reset the state of the timeline array
+        return @timelineObj.clearTimeline()
+    end
+    
+end

data/lib/fyipe/fyipeTransport.rb

@@ -0,0 +1,24 @@
+require 'httparty'
+
+class FyipeTransport
+    include HTTParty
+
+    def initialize( apiUrl)
+        # set up the api transporter
+        @apiUrl = apiUrl
+    end
+    
+    def sendErrorEventToServer(event)
+        response = makeApiRequest(event)
+        return response
+    end
+
+    private
+    def makeApiRequest(body)
+        # make api request and return response
+
+        response = self.class.post(@apiUrl, :headers => {'Content-Type'=>'application/json'}, :body => body.to_json).parsed_response
+
+        return response
+    end
+end

data/lib/fyipe/logtype.rb

@@ -0,0 +1,9 @@
+require 'ruby-enum'
+
+class LogType
+    include Ruby::Enum
+
+    define :INFO, "info"
+    define :WARNING, "warning"
+    define :ERROR, "error"
+end

data/lib/fyipe/timelineManager.rb

@@ -0,0 +1,41 @@
+class FyipeTimelineManager
+    def initialize(options)
+        @options = options
+        @timeLineStack = []
+    end
+
+
+    def addToTimeline(item)
+        addItemToTimeline(item)
+    end
+    
+    # return the timeline
+    def getTimeline()
+        return @timeLineStack
+    end
+    
+    # clear the timeline
+    def clearTimeline()
+        @timeLineStack = []
+    end 
+
+   
+    private
+    def addItemToTimeline(item)
+        # get the size of the stack
+        if (@options[:maxTimeline] != nil && (@timeLineStack.length() == @options[:maxTimeline].to_i))
+            return # It discards new timeline update once maximum is reached
+        end
+
+        # add time to it
+        # current date and time
+        time = Time.now
+        now = time.inspect
+
+        item["timestamp"] = now
+        
+        # add a new item to the stack
+        @timeLineStack.append(item)
+        return true
+    end
+end 

data/lib/fyipe/util.rb

@@ -0,0 +1,158 @@
+require 'securerandom'
+require_relative 'logtype'
+
+class Util 
+
+    def initialize(options)
+        @options = options
+    end
+
+    def v4()
+        return SecureRandom.uuid
+    end
+
+    def getErrorType(val)
+        enumValue = ""
+        LogType.each do |key, enum|
+            if (key.to_s.eql? "#{val}")
+                enumValue = enum.value
+            end
+        end
+        
+        return enumValue
+    end
+    def getExceptionStackTrace(exception)
+        frames = [];
+        lineNumber = 'N/A'
+
+        obj = {}
+        obj["type"] = exception.class
+        obj["message"] = exception.message
+        obj["lineNumber"] = lineNumber
+        
+        backtraces = exception.backtrace
+        backtraces != nil ?
+        backtraces.each do |backtrace|
+            breakdown = backtrace.split(":")
+            fileName = breakdown[0]
+            lineNumber = breakdown[1]
+            methodName = breakdown[2]
+            frame = {}
+            frame["fileName"] = fileName
+            frame["methodName"] = methodName
+            frame["lineNumber"] = lineNumber
+            frames.append(frame)
+        end
+        : nil
+
+        stacktrace = {}
+        stacktrace["frames"] = frames
+        
+        obj["stacktrace"] = stacktrace
+        obj["lineNumber"] = frames[0] ? frames[0]["lineNumber"] : lineNumber
+
+        # run only if user agreed to use this feature
+        if @options[:captureCodeSnippet] == true
+            obj = getErrorCodeSnippet(obj)
+        end
+
+        return obj
+    end
+
+    def getErrorCodeSnippet(errorObj)
+        frames = [] 
+        if errorObj["stacktrace"] != nil
+            frames = errorObj["stacktrace"]["frames"]
+        end
+
+        # get content related to each frame
+        contentFrame = [];
+
+        frames.each do |frame|
+            updateFrame = getFrameContent(frame)
+            # update content of each frame
+            updateFrameContent(frame)
+            contentFrame.append(updateFrame)
+        end
+
+        errorObj["stacktrace"]["frames"] = frames
+        return errorObj
+    end
+
+    def getFrameContent(frame)
+    
+        fileName = frame['fileName']
+
+        # # try to read the file content and save to frame
+        begin
+            file = File.open(fileName)
+            frame["sourceFile"] = file.readlines.map(&:chomp)
+
+        rescue  => exception
+            # something terrible went wrong
+            puts "Warning; Could read file: #{exception.message}"      
+        ensure
+            file.close      
+        end
+        
+        return frame
+    end
+
+    def updateFrameContent(frame)
+        lines = []
+        if frame["sourceFile"] != nil
+            lines = frame["sourceFile"]
+        end
+        localFrame = addCodeSnippetToFrame(lines, frame)
+        frame = localFrame
+        return frame
+    end
+
+    def addCodeSnippetToFrame(lines, frame, linesOfContext = 5)
+    
+        if lines.length() < 1 
+            return
+        end
+
+        lineNumber = 0
+        if frame['lineNumber'] != nil
+            lineNumber = frame['lineNumber'].to_i
+        end
+
+        maxLines = lines.length()
+        sourceLine = max(min(maxLines, lineNumber - 1), 0)
+        # attach the line before the error
+        frame['linesBeforeError'] = getPathOfLines(lines, max(0, sourceLine - linesOfContext), linesOfContext)
+        # attach the line after the error
+        frame['linesAfterError'] = getPathOfLines(
+            lines,
+            min(sourceLine + 1, maxLines),
+            1 + linesOfContext
+        )
+        # attach the error line
+        frame['errorLine'] = lines[min(maxLines - 1, sourceLine)]
+
+        # remove the source file
+        frame.delete('sourceFile')
+
+        return frame
+    end
+
+    private
+    def getPathOfLines(lines, start, count)
+        terminal = start + count
+        return lines[start..terminal]
+    end
+
+    private
+    def max (a,b)
+        a>b ? a : b
+    end
+
+    private
+    def min (a,b)
+        a<b ? a : b
+    end
+
+        
+end

data/lib/fyipe/version.rb

@@ -1,3 +1,4 @@
 module Fyipe
-    VERSION = '3.0.11516'
+    NAME = 'fyipe'
+    VERSION = '3.0.11910-qa'
 end

data/lib/fyipeTracker.rb

@@ -0,0 +1,262 @@
+require_relative 'fyipe/util'
+require_relative 'fyipe/fyipeListener'
+require_relative 'fyipe/fyipeTransport'
+require File.expand_path('./fyipe/version', __dir__)
+
+class FyipeTracker
+    # FyipeLogger constructor.
+    # @param string apiUrl
+    # @param string errorTrackerId
+    # @param string errorTrackerKey
+    
+    def initialize(apiUrl, errorTrackerId, errorTrackerKey, options = [])
+        # instance variable intialzation
+        @configKeys = ['baseUrl']
+        @MAX_ITEMS_ALLOWED_IN_STACK = 100
+        @errorTrackerId = errorTrackerId
+        setApiUrl(apiUrl) 
+        @errorTrackerKey = errorTrackerKey
+        @tags = []
+        @fingerprint = []
+        @options = {
+            'maxTimeline': 5,
+            'captureCodeSnippet': true
+        }
+        setUpOptions(options)
+        @util = Util.new(@options)
+        setEventId()
+        @listenerObj = FyipeListener.new(getEventId(), @options)
+        @apiTransport = FyipeTransport.new(@apiUrl)
+        # setUpExceptionHandlerListener()
+    end
+
+    def setApiUrl(apiUrl)
+        @apiUrl = apiUrl + '/error-tracker/' + @errorTrackerId + '/track';
+    end
+
+    def setUpOptions(options)
+        # set up options
+        if(options.class.to_s != "Hash")
+            return # ignore passed options if it is not an object
+        end
+
+        options.each do |key, value|
+            # proceed with current key if it is not in the config keys
+             if (!(@configKeys.include? key))
+                # if key is allowed in options
+                if (@options[key] != nil)
+                    # set max timeline properly after hecking conditions
+                    if key.to_s == 'maxTimeline'
+                        allowedValue = value
+                        if value > @MAX_ITEMS_ALLOWED_IN_STACK or value < 1
+                            allowedValue = @MAX_ITEMS_ALLOWED_IN_STACK
+                        end
+                        
+                        @options[key] = allowedValue
+                    elsif key.to_s == 'captureCodeSnippet'
+                            defaultVal = true
+                            # set boolean value if boolean or set default `true` if anything other than boolean is passed
+                            if [true, false].include? value # since there is no Boolean class in Ruby
+                                defaultVal = value
+                            end
+                            @options[key] = defaultVal
+                    end
+                end
+
+             end
+        end
+    end
+
+    def setEventId()
+        @eventId = @util.v4()
+    end
+    
+    def getEventId()
+        return @eventId
+    end
+
+    def addToTimeline(category, content, type)
+        timelineObj =  {}
+        timelineObj["category"] = category
+        timelineObj["data"] = content
+        timelineObj["type"] = type
+
+        @listenerObj.logCustomTimelineEvent(timelineObj)
+    end
+
+    def getTimeline()
+        return @listenerObj.getTimeline()
+    end
+
+    def setTag(key, value)
+        if (!((key.class.to_s.eql? "String") || (value.class.to_s.eql? "String")))
+            raise "Invalid Tag"
+        end
+        
+        exist = false
+        @tags.each do |tag|
+            if(tag['key'].to_s.eql? key)
+                # set the found flag
+                exist = true
+                # replace value if it exist
+                tag['value'] = value
+                break
+            end
+        end
+        if(!exist)
+            # push key and value if it doesnt
+            tag = {}
+            tag['key'] = key
+            tag['value'] = value
+            @tags.append(tag)
+        end
+    end
+
+    def setTags(tags)
+    
+        if (!(tags.class.to_s.eql? "Array"))
+            raise "Invalid Tags"
+        end
+        
+        tags.each do |tag|
+            if(tag[:key] != nil && tag[:value] != nil)
+                setTag(tag[:key], tag[:value])
+            end
+        end
+    end
+
+    def getTags()
+        return @tags
+    end
+
+    def setFingerPrint(key)
+        # get data type of the passed key
+        keyClassType = key.class.to_s
+
+        # routine check
+        if (keyClassType != "String" && keyClassType != "Array")
+            raise "Invalid Fingerprint"
+        end
+
+        fingerprint = key
+        if (keyClassType == "String")
+            fingerprint = [key]
+        end
+        
+        @fingerprint = fingerprint
+    end
+
+    def getFingerprint(errorMessage)
+    
+        # if no fingerprint exist currently
+        if (@fingerprint.length() < 1)
+            # set up finger print based on error since none exist
+            setFingerPrint(errorMessage)
+        end
+        
+        return @fingerprint
+    end
+
+    def captureMessage( message)
+        # set the a handled tag
+        setTag('handled', 'true')
+        messageObj = {}
+        messageObj["message"] = message 
+
+        prepareErrorObject('message', messageObj);
+
+        # send to the server
+        return sendErrorEventToServer()
+    end
+
+    def setUpExceptionHandlerListener()
+        # start listener
+        at_exit do
+            manageErrorObject($!) if $!         
+        end
+        
+    end
+    def manageErrorObject(exception)
+    
+        # construct the error object
+        errorObj = @utilObj.getExceptionStackTrace(exception);
+        
+        # set the a handled tag
+        setTag('handled', 'false');
+        # prepare to send to server
+        prepareErrorObject('error', errorObj);
+
+        # send to the server
+        return sendErrorEventToServer();
+    end
+    def prepareErrorObject(eventType, errorStackTrace) 
+        # set a last timeline as the error message
+        @listenerObj.logErrorEvent(errorStackTrace["message"], eventType)
+        
+        # get current timeline
+        timeline = getTimeline()
+        
+        tags = getTags()
+        fingerprint = getFingerprint(errorStackTrace["message"]) # default fingerprint will be the message from the error stacktrace
+        # get event ID
+        # Temporary display the state of the error stack, timeline and device details when an error occur
+        # prepare the event so it can be sent to the server
+        @event = {}
+        @event["type"] = eventType
+        @event["timeline"]= timeline
+        @event["exception"]= errorStackTrace
+        @event["eventId"]= getEventId()
+        @event["tags"]= tags
+        @event["fingerprint"]= fingerprint
+        @event["errorTrackerKey"]= @errorTrackerKey
+        @event["sdk"]= getSDKDetails()
+    end
+
+    def getCurrentEvent()
+        return @event
+    end
+
+    def captureException(exception)
+    
+        # construct the error object
+        exceptionObj = @util.getExceptionStackTrace(exception)
+
+        # set the a handled tag
+        setTag('handled', 'true')
+
+        prepareErrorObject('exception', exceptionObj)
+
+        # send to the server
+        return sendErrorEventToServer()
+    end
+    def sendErrorEventToServer()
+        response = nil
+        # send to API properly
+        response = @apiTransport.sendErrorEventToServer(@event)
+        # generate a new event Id
+        setEventId()
+        # clear the timeline after a successful call to the server
+        clear(getEventId())
+        return response
+    end
+
+    def clear(newEventId)
+        # clear tags
+        @tags = []
+        # clear fingerprint
+        @fingerprint = []
+        # clear timeline
+        @listenerObj.clearTimeline(newEventId)
+    end
+
+    def getSDKDetails()    
+        # default sdk details
+        sdkDetail = {}
+        sdkDetail["name"] = Fyipe::NAME
+        sdkDetail["version"] = Fyipe::VERSION
+
+        
+        return sdkDetail
+    end
+        
+end

data/spec/fyipe_tracker_spec.rb

@@ -0,0 +1,453 @@
+# spec/fyipe_tracker_spec.rb
+require_relative '../lib/fyipeTracker'
+require_relative 'helper'
+
+RSpec.configure do |config|
+    config.before(:suite){
+        # using $ registers the variable as a global variable
+        # ref: https://stackoverflow.com/a/19167379/6800815
+        $apiUrl = 'http://localhost:3002/api'
+        $helper = Helper.new()
+        sampleUser = $helper.getSampleUser()
+        $customTimeline = {}
+        $customTimeline["category"] = "cart"
+        $customTimeline["type"] = "info"
+        $customTimeline["content"] = { "message": "test-content"}
+
+        begin
+            # create user
+            createdUser = $helper.makeApiRequest($apiUrl+"/user/signup", sampleUser)
+
+            # get token and project
+            $token = createdUser['tokens']['jwtAccessToken']
+            $project = createdUser['project']
+
+            # create a component
+            component = { 'name' => $helper.getTitle() }
+            $createdComponent = $helper.makeApiRequest($apiUrl+"/component/"+$project["_id"], component, $token) 
+            
+            # create an errorTracker and set it as the global error tracker.
+            errorTrack = { 'name' => $helper.getTitle() }
+            $errorTracker = $helper.makeApiRequest($apiUrl+"/error-tracker/"+$project["_id"]+"/"+$createdComponent["_id"]+"/create", errorTrack, $token)
+        rescue => exception
+            puts "Couldnt create an error tracker to run a test, Error occured: #{exception.message}"
+        ensure
+            puts "All clear, Tests will commence now"
+        end 
+                        
+    }
+end
+
+RSpec.describe FyipeTracker do
+    it 'test_should_take_in_custom_timeline_event' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        timeline = tracker.getTimeline()
+        expect(timeline).to be_an_instance_of(Array)
+        expect(timeline.length()).to eql 1
+        expect($customTimeline["category"]).to eql timeline[0]["category"]
+    end
+    it 'test_should_ensure_timeline_event_contains_eventId_and_timestamp' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        timeline = tracker.getTimeline()
+
+        expect(timeline[0]["eventId"]).to be_an_instance_of(String)
+        expect(timeline[0]["timestamp"]).to be_an_instance_of(String)
+    end
+    it 'test_should_ensure_different_timeline_event_have_the_same_eventId' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], "error")
+
+        timeline = tracker.getTimeline()
+        expect(timeline.length()).to eql 2 # two timeline events
+        expect(timeline[0]["eventId"]).to eql timeline[1]["eventId"] # their eventId is the same, till there is an error sent to the server
+    end
+    it 'test_should_ensure_max_timline_cant_be_set_as_a_negative_number' do
+        options = {
+            "maxTimeline": -5
+        }
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"], options)
+
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], "error")
+
+        timeline = tracker.getTimeline()
+        expect(timeline.length()).to eql 2 # two timeline events
+    end
+    it 'test_should_ensure_new_timeline_event_after_max_timeline_are_discarded' do
+        options = {
+            "maxTimeline": 2
+        }
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"], options)
+
+        customTimeline2 = {}
+
+        customTimeline2["category"] = "logout"
+        customTimeline2["type"] = "success"
+        customTimeline2["content"] = {"message": "tester"}
+
+        # add 3 timeline events
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        tracker.addToTimeline(customTimeline2["category"], customTimeline2["content"], customTimeline2["type"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], "debug")
+
+        timeline = tracker.getTimeline()
+        
+        expect(options[:maxTimeline]).to eql timeline.length() # two timeline events
+        expect(timeline[0]["type"]).to eql $customTimeline["type"]
+        expect(timeline[1]["category"]).to eql customTimeline2["category"]
+    end
+
+    it 'test_should_add_tags' do 
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        tag = {
+            "key": "location",
+            "value": "Warsaw"
+        } 
+        tracker.setTag(tag[:key], tag[:value])
+        
+        availableTags = tracker.getTags()
+        expect(availableTags).to be_an_instance_of(Array)
+        expect(availableTags.length()).to eql 1
+        expect(tag[:key]).to eql availableTags[0]["key"]
+    end
+
+    it 'test_should_add_multiple_tags' do
+        
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        tags = []
+        tag = {
+            "key": "location",
+            "value": "Warsaw"
+        } 
+        tags.append(tag)
+
+        tagB = {
+            "key": "city",
+            "value": "Leeds"
+        } 
+        tags.append(tagB)
+
+        tagC = {
+            "key": "device",
+            "value": "iPhone"
+        } 
+        tags.append(tagC)
+
+        tracker.setTags(tags)
+
+        availableTags = tracker.getTags()
+        expect(availableTags).to be_an_instance_of(Array)
+        expect(availableTags.length()).to eql tags.length()
+    end
+
+    it 'test_should_overwrite_existing_keys_to_avoid_duplicate_tags' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        tags = []
+        tag = {
+            "key": "location",
+            "value": "Warsaw"
+        } 
+        tags.append(tag)
+
+        tagB = {
+            "key": "city",
+            "value": "Leeds"
+        } 
+        tags.append(tagB)
+
+        tagC = {
+            "key": "location",
+            "value": "Paris"
+        } 
+        tags.append(tagC)
+
+        tagD = {
+            "key": "device",
+            "value": "iPhone"
+        } 
+        tags.append(tagD)
+
+        tagE = {
+            "key": "location",
+            "value": "London"
+        } 
+        tags.append(tagE)
+
+        tracker.setTags(tags)
+
+        availableTags = tracker.getTags()
+        expect(availableTags).to be_an_instance_of(Array)
+        expect(availableTags.length()).to eql 3 # only 3 unique tags
+        expect(tagC[:key]).to eql availableTags[0]["key"]
+        expect(tagC[:value]).not_to eql availableTags[0]["value"]# old value for that tag location
+        expect(tagE[:key]).to eql availableTags[0]["key"]
+        expect(tagE[:value]).to eql availableTags[0]["value"]# latest value for that tag location
+    end
+
+    it 'test_should_create_fingerprint_as_message_for_error_capture_without_any_fingerprint' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = "Uncaught Exception"
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+        expect(event["fingerprint"][0]).to eql errorMessage
+    end
+    it 'test_should_use_defined_fingerprint_array_for_error_capture_with_fingerprint' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+
+        fingerprints = ['custom', 'errors']
+        tracker.setFingerPrint(fingerprints)
+        errorMessage = 'Uncaught Exception'
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+        expect(event["fingerprint"][0]).to eql fingerprints[0]
+        expect(event["fingerprint"][1]).to eql fingerprints[1]
+    end
+    it 'test_should_use_defined_fingerprint_string_for_error_capture_with_fingerprint' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        fingerprint = 'custom-fingerprint'
+        tracker.setFingerPrint(fingerprint)
+        errorMessage = 'Uncaught Exception'
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+        expect(event["fingerprint"][0]).to eql fingerprint
+    end
+    it 'test_should_create_an_event_ready_for_the_server_using_capture_message' do 
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = 'This is a test'
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+        expect(event["type"]).to eql "message"
+        expect(event["exception"]["message"]).to eql errorMessage
+    end 
+    it 'test_should_create_an_event_ready_for_the_server_while_having_the_timeline_with_same_event_id' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        
+        errorMessage = 'This is a test'
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+
+        expect(event["timeline"].length()).to eql 2
+        expect(event["eventId"]).to eql event["timeline"][0]["eventId"]
+        expect(event["exception"]["message"]).to eql errorMessage
+    end
+    it 'test_should_create_an_event_ready_for_the_server_using_capture_exception' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = 'Error Found'
+        tracker.captureException(Exception.new(errorMessage))
+        event = tracker.getCurrentEvent()
+
+        expect(event["type"]).to eql "exception"
+        expect(event["exception"]["message"]).to eql errorMessage
+    end
+    it 'test_should_create_an_event_with_array_of_stacktrace' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorType = ""
+        begin
+            divByZero = 1/0
+        rescue => ex
+            errorType = ex.class
+            tracker.captureException(ex)
+        end
+        event = tracker.getCurrentEvent()
+
+        expect(event["type"]).to eql "exception"
+        expect(event["exception"]["type"]).to eql errorType
+        expect(event["exception"]["stacktrace"]).to be_an_instance_of(Hash)
+        expect(event["exception"]["stacktrace"]["frames"]).to be_an_instance_of(Array)
+    end   
+    it 'test_should_create_an_event_with_the_object_of_the_stacktrace_in_place' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorType = ''
+        begin
+            divByZero= 1/0
+        rescue => ex
+            errorType = ex.class
+            tracker.captureException(ex)
+        end
+
+        event = tracker.getCurrentEvent()
+        frame = event["exception"]["stacktrace"]["frames"][0]
+        
+        expect(frame).to have_key('methodName')
+        expect(frame).to have_key('lineNumber')
+        expect(frame).to have_key('fileName')
+
+    end 
+    it 'test_should_create_an_event_and_new_event_should_have_different_id' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = 'random error occured'
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        event = tracker.captureMessage(errorMessage)
+
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        newEvent = nil
+        errorMessageException = ''
+        begin
+            divByZero= 1/0
+        rescue => ex
+            errorMessageException = ex.message
+            newEvent = tracker.captureException(ex)
+        end
+
+        # ensure that the first event have a type message, same error message
+        expect(event["type"]).to eql "message"
+        expect(event["content"]["message"]).to eql errorMessage
+
+
+        # ensure that the second event have a type exception, same error message
+        expect(newEvent["type"]).to eql "exception"
+        expect(newEvent["content"]["message"]).to eql errorMessageException
+
+        
+        # confim their eventId is different
+        expect(event["_id"]).not_to eql newEvent["_id"]
+    end
+    it 'test_should_create_an_event_that_has_timeline_and_new_event_having_timeline_and_tags' do 
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = 'random error caused midway'
+        errorMessageObj = '';
+
+        # add timeline to first tracker
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        event =tracker.captureMessage(errorMessage)
+
+        # add timeline and tag to second tracker
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+        tag = {
+            "key": "location",
+            "value": "Warsaw"
+        } 
+        tracker.setTag(tag[:key], tag[:value])
+        newEvent = nil
+        begin  
+            divByZero= 1/0
+        rescue => ex
+            errorMessageObj = ex.message
+            newEvent = tracker.captureException(ex)
+        end
+
+        # puts event["timeline"]
+        # ensure that the first event have a type message, same error message and two timeline (one custom, one generic)
+        expect(event["type"]).to eql "message"
+        expect(event["content"]["message"]).to eql errorMessage
+        expect(event["timeline"].length()).to eql 2
+        expect(event["tags"].length()).to eql 1 # the default event tag added
+
+        # ensure that the second event have a type exception, same error message and 2 tags
+        expect(newEvent["type"]).to eql "exception"
+        expect(newEvent["content"]["message"]).to eql errorMessageObj
+        expect(newEvent["timeline"].length()).to eql 2
+        expect(newEvent["tags"].length()).to eql 2 # the default and custom tag
+    end
+    it 'test_should_contain_version_number_and_sdk_name_in_captured_message' do
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"])
+
+        errorMessage = 'Error Found'
+        tracker.captureMessage(errorMessage)
+        event = tracker.getCurrentEvent()
+
+        expect(event["sdk"]["name"]).to be_an_instance_of(String)
+
+        expect(event['sdk']['version']).to match(/(([0-9])+\.([0-9])+\.([0-9])+)/)# confirm that the version follows the pattern XX.XX.XX where X is a non negative integer
+    end
+    it 'test_should_add_code_capture_to_stack_trace_when_flag_is_passed_in_options' do
+        options = {
+            "captureCodeSnippet": true
+        }
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"], options)
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        event = nil
+        errorMsg = ''
+        begin
+            divByZero = 1/0
+        rescue => ex
+            errorMsg = ex.message
+            event = tracker.captureException(ex)
+        end
+
+        expect(event["type"]).to eql "exception"
+        expect(event["content"]["message"]).to eql errorMsg
+        expect(event["content"]["stacktrace"]).to be_an_instance_of(Hash)
+        expect(event["content"]["stacktrace"]["frames"]).to be_an_instance_of(Array)
+        
+        
+        incidentFrame = event["content"]["stacktrace"]["frames"][0]
+        expect(incidentFrame).to have_key('linesBeforeError')
+        expect(incidentFrame).to have_key('linesAfterError')
+        expect(incidentFrame).to have_key('errorLine')
+    end
+    it 'test_should_not_add_code_capture_to_stack_trace_when_flag_is_passed_in_options' do
+        options = {
+            "captureCodeSnippet": false
+        }
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"], options)
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        event = nil
+        errorType = ''
+        begin
+            divByZero = 1/0
+        rescue => ex
+            errorType = ex.class.to_s
+            event = tracker.captureException(ex)
+        end
+
+        expect(event["type"]).to eql "exception"
+        expect(event["content"]["type"]).to eql errorType
+        expect(event["content"]["stacktrace"]).to be_an_instance_of(Hash)
+        expect(event["content"]["stacktrace"]["frames"]).to be_an_instance_of(Array)
+        
+        
+        incidentFrame = event["content"]["stacktrace"]["frames"][0]
+        expect(incidentFrame).to_not have_key('linesBeforeError')
+        expect(incidentFrame).to_not have_key('linesAfterError')
+        expect(incidentFrame).to_not have_key('errorLine')
+    end
+    it 'test_should_add_code_capture_to_stack_trace_by_default_when_unwanted_flag_is_passed_in_options' do
+        options = {
+            "captureCodeSnippet": "heyy" # sdk expects a true or false but it defaults to true if wrong value is sent
+        }
+        tracker = FyipeTracker.new($apiUrl, $errorTracker["_id"], $errorTracker["key"], options)
+        tracker.addToTimeline($customTimeline["category"], $customTimeline["content"], $customTimeline["type"])
+
+        event = nil
+        errorMsg = ''
+        begin
+            divByZero = 1/0
+        rescue => ex
+            errorMsg = ex.message
+            event = tracker.captureException(ex)
+        end
+
+        expect(event["type"]).to eql "exception"
+        expect(event["content"]["message"]).to eql errorMsg
+        expect(event["content"]["stacktrace"]).to be_an_instance_of(Hash)
+        expect(event["content"]["stacktrace"]["frames"]).to be_an_instance_of(Array)
+        
+        
+        incidentFrame = event["content"]["stacktrace"]["frames"][0]
+        expect(incidentFrame).to have_key('linesBeforeError')
+        expect(incidentFrame).to have_key('linesAfterError')
+        expect(incidentFrame).to have_key('errorLine')
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fyipe
 version: !ruby/object:Gem::Version
-  version: 3.0.11516
+  version: 3.0.11910.pre.qa
 platform: ruby
 authors:
 - HackerBay, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2021-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -28,16 +28,30 @@ dependencies:
   name: gem-release
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-enum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -140,9 +154,16 @@ files:
 - README.md
 - RakeFile
 - fyipe.gemspec
+- lib/fyipe/fyipeListener.rb
+- lib/fyipe/fyipeTransport.rb
+- lib/fyipe/logtype.rb
+- lib/fyipe/timelineManager.rb
+- lib/fyipe/util.rb
 - lib/fyipe/version.rb
 - lib/fyipeLogger.rb
+- lib/fyipeTracker.rb
 - spec/fyipe_logger_spec.rb
+- spec/fyipe_tracker_spec.rb
 - spec/helper.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Fyipe/ruby-sdk
@@ -160,9 +181,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6