datawire_mdk 2.0.15 → 2.0.16

data/lib/mdk_rtp.rb

@@ -0,0 +1,38 @@
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
+module Quark
+require "quark"
+def self.mdk_rtp; MdkRtp; end
+module MdkRtp
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'mdk_protocol' # 0 () ()
+
+
+##
+# Create a JSONParser that can read all messages to/from the MCP.
+
+def self.getRTPParser()
+    
+    parser = ::Quark.mdk_protocol.JSONParser.new()
+    parser.register("open", ::Quark.quark.reflect.QuarkClass.get("mdk_protocol.Open"))
+    parser.register("mdk.protocol.Open", ::Quark.quark.reflect.QuarkClass.get("mdk_protocol.Open"))
+    parser.register("close", ::Quark.quark.reflect.QuarkClass.get("mdk_protocol.Close"))
+    parser.register("mdk.protocol.Close", ::Quark.quark.reflect.QuarkClass.get("mdk_protocol.Close"))
+    parser.register("discovery.protocol.Close", ::Quark.quark.reflect.QuarkClass.get("mdk_protocol.Close"))
+    parser.register("active", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Active"))
+    parser.register("discovery.protocol.Expire", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Expire"))
+    parser.register("expire", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Expire"))
+    parser.register("discovery.protocol.Expire", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Expire"))
+    parser.register("clear", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Clear"))
+    parser.register("discovery.protocol.Clear", ::Quark.quark.reflect.QuarkClass.get("mdk_discovery.protocol.Clear"))
+    parser.register("log", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogEvent"))
+    parser.register("logack", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
+    parser.register("mdk_tracing.protocol.LogAckEvent", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
+    parser.register("subscribe", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.Subscribe"))
+    return parser
+
+
+    nil
+end
+end # module MdkRtp
+end # module Quark

data/lib/mdk_runtime.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_runtime; MdkRuntime; end
@@ -9,9 +9,9 @@ require_relative 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
 require_relative 'mdk_runtime/files' # 0 ('mdk_runtime',) ()
 require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
 require_relative 'quark/error' # 0 ('quark',) ()
+require_relative 'quark/os' # 0 ('quark',) ()
 require_relative 'quark' # 0 () ()
 require_relative 'quark/concurrent' # 0 ('quark',) ()
-require_relative 'quark/os' # 0 ('quark',) ()
 
 
 def self.Dependencies; Dependencies; end
@@ -622,6 +622,19 @@ class WSClosed < ::DatawireQuarkCore::QuarkObject
 end
 WSClosed.unlazy_statics
 
+##
+# On Python, log to a per-process file if MDK_LOG_MESSAGES env variable is set.
+
+def self.log_to_file(s)
+    
+    if ((::Quark.quark.os.Environment.getEnvironment().__get__("MDK_LOG_MESSAGES")) != (nil))
+        o = ""
+    end
+
+
+    nil
+end
+
 def self.QuarkRuntimeWSActor; QuarkRuntimeWSActor; end
 ##
 # WSActor that uses current Quark runtime as temporary expedient.
@@ -698,6 +711,7 @@ class QuarkRuntimeWSActor < ::DatawireQuarkCore::QuarkObject
         self.logTS(("   message is from ") + ((origin).to_s))
         if ((((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("quark.String")) && (((self).state) == ("CONNECTED")))
             self.logTS(("   send-ish, message is: ") + ((message).to_s))
+            ::Quark.mdk_runtime.log_to_file(("sending: ") + (::DatawireQuarkCore.cast(message) { ::String }))
             (self).socket.send(::DatawireQuarkCore.cast(message) { ::String })
             return
         end
@@ -745,6 +759,7 @@ class QuarkRuntimeWSActor < ::DatawireQuarkCore::QuarkObject
         
         self.logPrologue("onWSMessage")
         self.logTS(("onWSMessage, message is: ") + (message))
+        ::Quark.mdk_runtime.log_to_file(("received: ") + (message))
         (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSMessage.new(message), (self).originator)
 
         nil

data/lib/mdk_runtime/actors.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_runtime; MdkRuntime; end

data/lib/mdk_runtime/files.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_runtime; MdkRuntime; end

data/lib/mdk_runtime/promise.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_runtime; MdkRuntime; end

data/lib/mdk_tracing.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_tracing; MdkTracing; end
@@ -8,9 +8,10 @@ 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 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
 require_relative 'quark' # 0 () ()
 require_relative 'mdk_runtime' # 0 () ()
-require_relative 'mdk_introspection' # 0 () ()
+require_relative 'mdk_rtp' # 0 () ()
 
 
 def self.SharedContextInitializer; SharedContextInitializer; end
@@ -70,18 +71,18 @@ SharedContextInitializer.unlazy_statics
 
 def self.Tracer; Tracer; end
 class Tracer < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :logger, :url, :queryURL, :token, :lastPoll, :_context, :_client, :runtime
+    attr_accessor :logger, :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)
+    def initialize(runtime, wsclient)
         
         self.__init_fields__
         (self).runtime = runtime
+        (self)._client = ::Quark.mdk_tracing.protocol.TracingClient.new(self, wsclient)
 
         nil
     end
@@ -89,45 +90,45 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
 
 
 
+    ##
+    # Backwards compatibility.
+
     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 ::Quark.mdk_tracing.Tracer.withURLAndToken(url, token)
+
+        nil
+    end
+
+    def self.withURLAndToken(url, token)
+        
+        runtime = ::Quark.mdk_runtime.defaultRuntime()
+        wsclient = ::Quark.mdk_protocol.WSClient.new(runtime, ::Quark.mdk_rtp.getRTPParser(), url, token)
+        (runtime).dispatcher.startActor(wsclient)
+        newTracer = ::Quark.mdk_tracing.Tracer.new(runtime, wsclient)
+        (runtime).dispatcher.startActor(newTracer)
         return newTracer
 
         nil
     end
 
-    def _openIfNeeded()
+    def onStart(dispatcher)
         
-        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
+        dispatcher.startActor(@_client)
 
         nil
     end
 
-    def stop()
+    def onStop()
         
-        if ((@_client) != (nil))
-            (@runtime).dispatcher.stopActor(@_client)
-        end
+        (@runtime).dispatcher.stopActor(@_client)
+
+        nil
+    end
+
+    def onMessage(origin, mesage)
+        
+        nil
 
         nil
     end
@@ -182,9 +183,11 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Send a log message to the server.
+
     def log(procUUID, level, category, text)
         
-        self._openIfNeeded()
         ctx = self.getContext()
         ctx.tick()
         @logger.trace(("CTX ") + (ctx.toString()))
@@ -201,84 +204,13 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
         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"
@@ -291,15 +223,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
         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
@@ -322,15 +245,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
         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
@@ -350,9 +264,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
     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

data/lib/mdk_tracing/api.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_tracing; MdkTracing; end
@@ -124,6 +124,7 @@ class GetLogEventsResult < ::Quark.mdk_protocol.Serializable
     attr_accessor :result
     extend ::DatawireQuarkCore::Static
 
+    static quark_List_mdk_tracing_protocol_LogEvent__ref: -> { nil }
     static mdk_tracing_api_GetLogEventsResult_ref: -> { nil }
 
 

data/lib/mdk_tracing/protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_tracing; MdkTracing; end
@@ -11,156 +11,14 @@ require_relative '../mdk_protocol' # 0 () ('mdk_tracing',)
 require_relative '../mdk_tracing' # 0 () ('mdk_tracing',)
 require_relative '../quark' # 0 () ('mdk_tracing',)
 require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_tracing',)
-require_relative '../mdk_runtime' # 0 () ('mdk_tracing',)
 
 
-def self.TracingHandler; TracingHandler; end
-class TracingHandler < ::DatawireQuarkCore::QuarkObject
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_tracing_protocol_TracingHandler_ref: -> { nil }
-
-
-
-    def initialize()
-        self.__init_fields__
-
-        nil
-    end
-
-
-
-
-    def onLogEvent(event)
-        
-        nil
-
-        nil
-    end
-
-    def onLogAck(ack)
-        
-        nil
-
-        nil
-    end
-
-    def onSubscribe(sub)
-        
-        nil
-
-        nil
-    end
-
-    def __init_fields__()
-        
-
-        nil
-    end
-
-
-end
-TracingHandler.unlazy_statics
-
-def self.TracingEvent; TracingEvent; end
-##
-# A single event in the stream that Tracing has to manage.
-
-class TracingEvent < ::Quark.mdk_protocol.ProtocolEvent
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_tracing_protocol_TracingEvent_ref: -> { nil }
-
-
-
-    def initialize()
-        
-        super()
-
-        nil
-    end
-
-
-
-
-    def self.construct(type)
-        
-        result = ::Quark.mdk_protocol.ProtocolEvent.construct(type)
-        if ((result) != (nil))
-            return result
-        end
-        if (::Quark.mdk_tracing.protocol.LogEvent._discriminator.matches(type))
-            return ::Quark.mdk_tracing.protocol.LogEvent.new()
-        end
-        if (::Quark.mdk_tracing.protocol.LogAck._discriminator.matches(type))
-            return ::Quark.mdk_tracing.protocol.LogAck.new()
-        end
-        if (::Quark.mdk_tracing.protocol.Subscribe._discriminator.matches(type))
-            return ::Quark.mdk_tracing.protocol.Subscribe.new()
-        end
-        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.ProtocolEvent }
-
-        nil
-    end
-
-    def self.decode(encoded)
-        
-        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_tracing.protocol.TracingEvent", encoded)) { ::Quark.mdk_protocol.ProtocolEvent }
-
-        nil
-    end
-
-    def dispatch(handler)
-        
-        self.dispatchTracingEvent(::DatawireQuarkCore.cast(handler) { ::Quark.mdk_tracing.protocol.TracingHandler })
-
-        nil
-    end
-
-    def dispatchTracingEvent(handler)
-        raise NotImplementedError, '`TracingEvent.dispatchTracingEvent` is an abstract method'
-
-        nil
-    end
-
-    def _getClass()
-        
-        return "mdk_tracing.protocol.TracingEvent"
-
-        nil
-    end
-
-    def _getField(name)
-        
-        return nil
-
-        nil
-    end
-
-    def _setField(name, value)
-        
-        nil
-
-        nil
-    end
-
-    def __init_fields__()
-        
-        super
-
-        nil
-    end
-
-
-end
-TracingEvent.unlazy_statics
-
 def self.LogEvent; LogEvent; end
-class LogEvent < ::Quark.mdk_tracing.protocol.TracingEvent
+class LogEvent < ::Quark.mdk_protocol.Serializable
     attr_accessor :context, :timestamp, :node, :level, :category, :contentType, :text, :sequence, :sync
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["log"])) }
+    static _json_type: -> { "log" }
     static mdk_tracing_protocol_LogEvent_ref: -> { nil }
 
 
@@ -175,13 +33,6 @@ class LogEvent < ::Quark.mdk_tracing.protocol.TracingEvent
 
 
 
-    def dispatchTracingEvent(handler)
-        
-        handler.onLogEvent(self)
-
-        nil
-    end
-
     def toString()
         
         return (((((((((((((((("<LogEvent ") + ((@sequence).to_s)) + (" @")) + ((@timestamp).to_s)) + (" ")) + (@context.toString())) + (", ")) + (@node)) + (", ")) + (@level)) + (", ")) + (@category)) + (", ")) + (@contentType)) + (", ")) + (@text)) + (">")
@@ -198,8 +49,8 @@ class LogEvent < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_tracing.protocol.LogEvent._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_tracing.protocol.LogEvent._json_type
         end
         if ((name) == ("context"))
             return (self).context
@@ -235,8 +86,8 @@ class LogEvent < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_tracing.protocol.LogEvent._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_tracing.protocol.LogEvent._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("context"))
             (self).context = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SharedContext }
@@ -290,10 +141,10 @@ end
 LogEvent.unlazy_statics
 
 def self.Subscribe; Subscribe; end
-class Subscribe < ::Quark.mdk_tracing.protocol.TracingEvent
+class Subscribe < ::Quark.mdk_protocol.Serializable
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["subscribe"])) }
+    static _json_type: -> { "subscribe" }
     static mdk_tracing_protocol_Subscribe_ref: -> { nil }
 
 
@@ -308,13 +159,6 @@ class Subscribe < ::Quark.mdk_tracing.protocol.TracingEvent
 
 
 
-    def dispatchTracingEvent(handler)
-        
-        handler.onSubscribe(self)
-
-        nil
-    end
-
     def toString()
         
         return "<Subscribe>"
@@ -331,8 +175,8 @@ class Subscribe < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_tracing.protocol.Subscribe._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_tracing.protocol.Subscribe._json_type
         end
         return nil
 
@@ -341,8 +185,8 @@ class Subscribe < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_tracing.protocol.Subscribe._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_tracing.protocol.Subscribe._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
 
         nil
@@ -360,11 +204,11 @@ end
 Subscribe.unlazy_statics
 
 def self.LogAck; LogAck; end
-class LogAck < ::Quark.mdk_tracing.protocol.TracingEvent
+class LogAck < ::Quark.mdk_protocol.Serializable
     attr_accessor :sequence
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["logack", "mdk_tracing.protocol.LogAckEvent"])) }
+    static _json_type: -> { "logack" }
     static mdk_tracing_protocol_LogAck_ref: -> { nil }
 
 
@@ -379,13 +223,6 @@ class LogAck < ::Quark.mdk_tracing.protocol.TracingEvent
 
 
 
-    def dispatchTracingEvent(handler)
-        
-        handler.onLogAck(self)
-
-        nil
-    end
-
     def toString()
         
         return (("<LogAck ") + ((@sequence).to_s)) + (">")
@@ -402,8 +239,8 @@ class LogAck < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_tracing.protocol.LogAck._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_tracing.protocol.LogAck._json_type
         end
         if ((name) == ("sequence"))
             return (self).sequence
@@ -415,8 +252,8 @@ class LogAck < ::Quark.mdk_tracing.protocol.TracingEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_tracing.protocol.LogAck._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_tracing.protocol.LogAck._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("sequence"))
             (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
@@ -438,19 +275,20 @@ end
 LogAck.unlazy_statics
 
 def self.TracingClient; TracingClient; end
-class TracingClient < ::Quark.mdk_protocol.WSClient
-    attr_accessor :_tracer, :_started, :_mutex, :_handler, :_dispatcher, :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_logged, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_myLog
+class TracingClient < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_tracer, :_started, :_mutex, :_handler, :_dispatcher, :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_logged, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_wsclient, :_sock, :_myLog
     extend ::DatawireQuarkCore::Static
 
     static mdk_tracing_protocol_TracingClient_ref: -> { nil }
 
 
 
-    def initialize(tracer, runtime)
+    def initialize(tracer, wsclient)
         
-        super(runtime)
-        (self)._dispatcher = (runtime).dispatcher
+        self.__init_fields__
         @_tracer = tracer
+        @_wsclient = wsclient
+        wsclient.subscribe(self)
 
         nil
     end
@@ -466,84 +304,59 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         nil
     end
 
-    def url()
-        
-        return (@_tracer).url
-
-        nil
-    end
-
-    def token()
-        
-        return (@_tracer).token
-
-        nil
-    end
+    ##
+    # Attach a subscriber that will receive results of queries.
 
-    def isStarted()
+    def subscribe(handler)
         
         @_mutex.acquire()
-        result = ((@_started) || (((@_buffered).size) > (0))) || ((@_handler) != (nil))
+        @_handler = handler
         @_mutex.release()
-        return result
 
         nil
     end
 
-    def _startIfNeeded()
+    def onStart(dispatcher)
         
-        if (!(@_started))
-            (self)._dispatcher.startActor(self)
-            @_started = true
-        end
+        (self)._dispatcher = dispatcher
 
         nil
     end
 
-    def subscribe(handler)
+    def onStop()
         
-        @_mutex.acquire()
-        @_handler = handler
-        self._startIfNeeded()
-        @_mutex.release()
-
         nil
-    end
-
-    def onStart(dispatcher)
-        
-        method(:onStart).super_method.call(dispatcher)
 
         nil
     end
 
-    def onStop()
+    def onMessage(origin, message)
         
-        @_started = false
-        method(:onStop).super_method.call()
+        ::Quark.mdk_protocol._subscriberDispatch(self, message)
 
         nil
     end
 
-    def startup()
+    def onWSConnected(websock)
         
         @_mutex.acquire()
+        (self)._sock = websock
         while (((@_inFlight).size) > (0)) do
             evt = (@_inFlight).delete_at(((@_inFlight).size) - (1))
             (@_buffered).insert((0), (evt))
             @_failedSends = (@_failedSends) + ((1))
             self._debug(("no ack for #") + (((evt).sequence).to_s))
         end
-        self._debug(("Starting up! with connection ") + (((self).sock).to_s))
+        self._debug(("Starting up! with connection ") + (((self)._sock).to_s))
         if ((@_handler) != (nil))
-            (self).dispatcher.tell(self, ::Quark.mdk_tracing.protocol.Subscribe.new().encode(), (self).sock)
+            (self)._dispatcher.tell(self, ::Quark.mdk_tracing.protocol.Subscribe.new().encode(), (self)._sock)
         end
         @_mutex.release()
 
         nil
     end
 
-    def pump()
+    def onPump()
         
         @_mutex.acquire()
         while (((@_buffered).size) > (0)) do
@@ -555,23 +368,29 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
                 @_lastSyncTime = (evt).timestamp
                 debugSuffix = " with sync set"
             end
-            (self).dispatcher.tell(self, evt.encode(), (self).sock)
+            (self)._dispatcher.tell(self, evt.encode(), (self)._sock)
             (evt).sync = 0
             @_sent = (@_sent) + ((1))
-            self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + (((self).sock).to_s))
+            self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + (((self)._sock).to_s))
         end
         @_mutex.release()
 
         nil
     end
 
-    def onWSMessage(message)
+    def onMessageFromServer(message)
         
-        event = ::Quark.mdk_tracing.protocol.TracingEvent.decode(message)
-        if ((event) == (nil))
+        type = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((type) == ("mdk_tracing.protocol.LogEvent"))
+            event = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_tracing.protocol.LogEvent }
+            self.onLogEvent(event)
+            return
+        end
+        if ((type) == ("mdk_tracing.protocol.LogAck"))
+            ack = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_tracing.protocol.LogAck }
+            self.onLogAck(ack)
             return
         end
-        event.dispatch(self)
 
         nil
     end
@@ -604,6 +423,9 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         nil
     end
 
+    ##
+    # Queue a log message for delivery to the server.
+
     def log(evt)
         
         @_mutex.acquire()
@@ -612,7 +434,6 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         @_logged = (@_logged) + ((1))
         (@_buffered) << (evt)
         self._debug(("logged #") + (((evt).sequence).to_s))
-        self._startIfNeeded()
         @_mutex.release()
 
         nil
@@ -627,48 +448,6 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
 
     def _getField(name)
         
-        if ((name) == ("logger"))
-            return (self).logger
-        end
-        if ((name) == ("firstDelay"))
-            return (self).firstDelay
-        end
-        if ((name) == ("maxDelay"))
-            return (self).maxDelay
-        end
-        if ((name) == ("reconnectDelay"))
-            return (self).reconnectDelay
-        end
-        if ((name) == ("ttl"))
-            return (self).ttl
-        end
-        if ((name) == ("tick"))
-            return (self).tick
-        end
-        if ((name) == ("sock"))
-            return (self).sock
-        end
-        if ((name) == ("sockUrl"))
-            return (self).sockUrl
-        end
-        if ((name) == ("lastConnectAttempt"))
-            return (self).lastConnectAttempt
-        end
-        if ((name) == ("lastHeartbeat"))
-            return (self).lastHeartbeat
-        end
-        if ((name) == ("timeService"))
-            return (self).timeService
-        end
-        if ((name) == ("schedulingActor"))
-            return (self).schedulingActor
-        end
-        if ((name) == ("websockets"))
-            return (self).websockets
-        end
-        if ((name) == ("dispatcher"))
-            return (self).dispatcher
-        end
         if ((name) == ("_tracer"))
             return (self)._tracer
         end
@@ -711,6 +490,12 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         if ((name) == ("_lastSyncTime"))
             return (self)._lastSyncTime
         end
+        if ((name) == ("_wsclient"))
+            return (self)._wsclient
+        end
+        if ((name) == ("_sock"))
+            return (self)._sock
+        end
         if ((name) == ("_myLog"))
             return (self)._myLog
         end
@@ -721,48 +506,6 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
 
     def _setField(name, value)
         
-        if ((name) == ("logger"))
-            (self).logger = value
-        end
-        if ((name) == ("firstDelay"))
-            (self).firstDelay = ::DatawireQuarkCore.cast(value) { ::Float }
-        end
-        if ((name) == ("maxDelay"))
-            (self).maxDelay = ::DatawireQuarkCore.cast(value) { ::Float }
-        end
-        if ((name) == ("reconnectDelay"))
-            (self).reconnectDelay = ::DatawireQuarkCore.cast(value) { ::Float }
-        end
-        if ((name) == ("ttl"))
-            (self).ttl = ::DatawireQuarkCore.cast(value) { ::Float }
-        end
-        if ((name) == ("tick"))
-            (self).tick = ::DatawireQuarkCore.cast(value) { ::Float }
-        end
-        if ((name) == ("sock"))
-            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WSActor }
-        end
-        if ((name) == ("sockUrl"))
-            (self).sockUrl = ::DatawireQuarkCore.cast(value) { ::String }
-        end
-        if ((name) == ("lastConnectAttempt"))
-            (self).lastConnectAttempt = ::DatawireQuarkCore.cast(value) { ::Integer }
-        end
-        if ((name) == ("lastHeartbeat"))
-            (self).lastHeartbeat = ::DatawireQuarkCore.cast(value) { ::Integer }
-        end
-        if ((name) == ("timeService"))
-            (self).timeService = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
-        end
-        if ((name) == ("schedulingActor"))
-            (self).schedulingActor = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
-        end
-        if ((name) == ("websockets"))
-            (self).websockets = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WebSockets }
-        end
-        if ((name) == ("dispatcher"))
-            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
-        end
         if ((name) == ("_tracer"))
             (self)._tracer = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.Tracer }
         end
@@ -805,6 +548,12 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         if ((name) == ("_lastSyncTime"))
             (self)._lastSyncTime = ::DatawireQuarkCore.cast(value) { ::Integer }
         end
+        if ((name) == ("_wsclient"))
+            (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
+        end
+        if ((name) == ("_sock"))
+            (self)._sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
         if ((name) == ("_myLog"))
             (self)._myLog = value
         end
@@ -812,16 +561,8 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         nil
     end
 
-    def onSubscribe(sub)
-        
-        nil
-
-        nil
-    end
-
     def __init_fields__()
         
-        super
         self._tracer = nil
         self._started = false
         self._mutex = ::DatawireQuarkCore::Lock.new()
@@ -836,6 +577,8 @@ class TracingClient < ::Quark.mdk_protocol.WSClient
         self._failedSends = 0
         self._recorded = 0
         self._lastSyncTime = 0
+        self._wsclient = nil
+        self._sock = nil
         self._myLog = ::Quark.quark._getLogger("TracingClient")
 
         nil