datawire_mdk 2.0.5

data/lib/mdk_tracing.rb

@@ -0,0 +1,369 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_tracing; MdkTracing; end
+module MdkTracing
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'mdk_tracing/api' # 0 ('mdk_tracing',) ()
+require_relative 'mdk_tracing/protocol' # 0 ('mdk_tracing',) ()
+require_relative 'mdk_protocol' # 0 () ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'quark' # 0 () ()
+require_relative 'mdk_runtime' # 0 () ()
+require_relative 'mdk_introspection' # 0 () ()
+
+
+def self.SharedContextInitializer; SharedContextInitializer; end
+class SharedContextInitializer < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_SharedContextInitializer_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.SharedContext }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.SharedContextInitializer"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+SharedContextInitializer.unlazy_statics
+
+def self.Tracer; Tracer; end
+class Tracer < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :url, :queryURL, :token, :lastPoll, :_context, :_client, :runtime
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_tracing_protocol_LogEvent__ref: -> { nil }
+    static mdk_tracing_Tracer_ref: -> { nil }
+
+
+
+    def initialize(runtime)
+        
+        self.__init_fields__
+        (self).runtime = runtime
+
+        nil
+    end
+
+
+
+
+    def self.withURLsAndToken(url, queryURL, token)
+        
+        newTracer = ::Quark.mdk_tracing.Tracer.new(::Quark.mdk_runtime.defaultRuntime())
+        (newTracer).url = url
+        if (((queryURL) == (nil)) || (((queryURL).size) == (0)))
+            parsedURL = ::Quark.quark.URL.parse(url)
+            if (((parsedURL).scheme) == ("ws"))
+                (parsedURL).scheme = "http"
+            else
+                (parsedURL).scheme = "https"
+            end
+            (parsedURL).path = "/api/v1/logs"
+            (newTracer).queryURL = parsedURL.toString()
+        else
+            (newTracer).queryURL = queryURL
+        end
+        (newTracer).token = token
+        return newTracer
+
+        nil
+    end
+
+    def _openIfNeeded()
+        
+        if ((@_client) == (nil))
+            @_client = ::Quark.mdk_tracing.protocol.TracingClient.new(self, @runtime)
+        end
+        if ((@token) == (nil))
+            @token = ::Quark.mdk_introspection.DatawireToken.getToken(@runtime.getEnvVarsService())
+        end
+
+        nil
+    end
+
+    def stop()
+        
+        if ((@_client) != (nil))
+            (@runtime).dispatcher.stopActor(@_client)
+        end
+
+        nil
+    end
+
+    def initContext()
+        
+        @_context.setValue(::Quark.mdk_protocol.SharedContext.new())
+
+        nil
+    end
+
+    def joinContext(context)
+        
+        @_context.setValue(context.start_span())
+
+        nil
+    end
+
+    def joinEncodedContext(encodedContext)
+        
+        newContext = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
+        self.joinContext(newContext)
+
+        nil
+    end
+
+    def getContext()
+        
+        return @_context.getValue()
+
+        nil
+    end
+
+    def setContext(ctx)
+        
+        @_context.setValue(ctx)
+
+        nil
+    end
+
+    def start_span()
+        
+        @_context.setValue(self.getContext().start_span())
+
+        nil
+    end
+
+    def finish_span()
+        
+        @_context.setValue(self.getContext().finish_span())
+
+        nil
+    end
+
+    def log(procUUID, level, category, text)
+        
+        self._openIfNeeded()
+        ctx = self.getContext()
+        ctx.tick()
+        @logger.trace(("CTX ") + (ctx.toString()))
+        evt = ::Quark.mdk_tracing.protocol.LogEvent.new()
+        (evt).context = ctx.copy()
+        (evt).timestamp = ::Quark.quark.now()
+        (evt).node = procUUID
+        (evt).level = level
+        (evt).category = category
+        (evt).contentType = "text/plain"
+        (evt).text = text
+        @_client.log(evt)
+
+        nil
+    end
+
+    def poll()
+        
+        self._openIfNeeded()
+        @logger.trace("Polling for logs...")
+        rightNow = ::Quark.quark.now()
+        result = self.query(@lastPoll, rightNow)
+        @lastPoll = rightNow
+        return result.andThen(::Quark.quark._BoundMethod.new(self, "deresultify", ::DatawireQuarkCore::List.new([])))
+
+        nil
+    end
+
+    def subscribe(handler)
+        
+        self._openIfNeeded()
+        @_client.subscribe(handler)
+
+        nil
+    end
+
+    def deresultify(result)
+        
+        @logger.trace((("got ") + ((((result).result).size).to_s)) + (" log events"))
+        return (result).result
+
+        nil
+    end
+
+    ##
+    # Query the trace logs. startTimeMillis and endTimeMillis are milliseconds since the UNIX epoch.
+
+    def query(startTimeMillis, endTimeMillis)
+        
+        args = ::DatawireQuarkCore::List.new([])
+        reqID = "Query "
+        if ((startTimeMillis) >= ((0)))
+            (args) << (("startTime=") + ((startTimeMillis).to_s))
+            reqID = (reqID) + ((startTimeMillis).to_s)
+        end
+        reqID = (reqID) + ("-")
+        if ((endTimeMillis) >= ((0)))
+            (args) << (("endTime=") + ((endTimeMillis).to_s))
+            reqID = (reqID) + ((endTimeMillis).to_s)
+        end
+        url = (self).queryURL
+        if (((args).size) > (0))
+            url = ((url) + ("?")) + ((args).join("&"))
+        end
+        req = ::DatawireQuarkCore::HTTP::Request.new(url)
+        req.setMethod("GET")
+        req.setHeader("Content-Type", "application/json")
+        req.setHeader("Authorization", ("Bearer ") + ((self).token))
+        return ::Quark.quark.IO.httpRequest(req).andThen(::Quark.quark._BoundMethod.new(self, "handleQueryResponse", ::DatawireQuarkCore::List.new([])))
+
+        nil
+    end
+
+    def handleQueryResponse(response)
+        
+        code = response.getCode()
+        body = response.getBody()
+        if ((code) == (200))
+            return ::Quark.mdk_tracing.api.GetLogEventsResult.decode(body)
+        else
+            error = ""
+            if (((body).size) > (0))
+                error = body
+            end
+            if (((error).size) < (1))
+                error = ("HTTP response ") + ((code).to_s)
+            end
+            @logger.error(("query failure: ") + (error))
+            return ::Quark.quark.HTTPError.new(error)
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.Tracer"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("url"))
+            return (self).url
+        end
+        if ((name) == ("queryURL"))
+            return (self).queryURL
+        end
+        if ((name) == ("token"))
+            return (self).token
+        end
+        if ((name) == ("lastPoll"))
+            return (self).lastPoll
+        end
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("_client"))
+            return (self)._client
+        end
+        if ((name) == ("runtime"))
+            return (self).runtime
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("url"))
+            (self).url = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("queryURL"))
+            (self).queryURL = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("token"))
+            (self).token = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("lastPoll"))
+            (self).lastPoll = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
+        end
+        if ((name) == ("_client"))
+            (self)._client = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.protocol.TracingClient }
+        end
+        if ((name) == ("runtime"))
+            (self).runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("MDK Tracer")
+        self.url = "wss://tracing.datawire.io/ws/v1"
+        self.queryURL = "https://tracing.datawire.io/api/v1/logs"
+        self.token = nil
+        self.lastPoll = 0
+        self._context = ::DatawireQuarkCore::TLS.new(::Quark.mdk_tracing.SharedContextInitializer.new())
+        self._client = nil
+        self.runtime = nil
+
+        nil
+    end
+
+
+end
+Tracer.unlazy_statics
+end # module MdkTracing
+end # module Quark

data/lib/mdk_tracing/api.rb

@@ -0,0 +1,188 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_tracing; MdkTracing; end
+module MdkTracing
+def self.api; Api; end
+module Api
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_tracing',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_tracing',)
+require_relative '../mdk_protocol' # 0 () ('mdk_tracing',)
+require_relative '../quark' # 0 () ('mdk_tracing',)
+require_relative 'protocol' # 1 () ()
+
+
+def self.ApiHandler; ApiHandler; end
+class ApiHandler < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_api_ApiHandler_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Retrieves zero or more events based on the provided request parameters.
+
+    def getLogEvents(request)
+        raise NotImplementedError, '`ApiHandler.getLogEvents` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+ApiHandler.unlazy_statics
+
+def self.GetLogEventsRequest; GetLogEventsRequest; end
+class GetLogEventsRequest < ::Quark.mdk_protocol.Serializable
+    attr_accessor :startTime, :endTime
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_api_GetLogEventsRequest_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def self.decode(encoded)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_tracing.api.GetLogEventsRequest", encoded)) { ::Quark.mdk_tracing.api.GetLogEventsRequest }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.api.GetLogEventsRequest"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("startTime"))
+            return (self).startTime
+        end
+        if ((name) == ("endTime"))
+            return (self).endTime
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("startTime"))
+            (self).startTime = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("endTime"))
+            (self).endTime = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.startTime = 0
+        self.endTime = ::Quark.quark.now()
+
+        nil
+    end
+
+
+end
+GetLogEventsRequest.unlazy_statics
+
+def self.GetLogEventsResult; GetLogEventsResult; end
+class GetLogEventsResult < ::Quark.mdk_protocol.Serializable
+    attr_accessor :result
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_api_GetLogEventsResult_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def self.decode(encoded)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_tracing.api.GetLogEventsResult", encoded)) { ::Quark.mdk_tracing.api.GetLogEventsResult }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.api.GetLogEventsResult"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("result"))
+            return (self).result
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("result"))
+            (self).result = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.result = nil
+
+        nil
+    end
+
+
+end
+GetLogEventsResult.unlazy_statics
+end # module Api
+end # module MdkTracing
+end # module Quark