datawire_mdk 2.0.22 → 2.0.23

data/lib/mdk.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk; Mdk; end
@@ -10,6 +10,7 @@ require_relative 'mdk_discovery' # 0 () ()
 require_relative 'quark' # 0 () ()
 require_relative 'mdk_protocol' # 0 () ()
 require_relative 'mdk_tracing' # 0 () ()
+require_relative 'mdk_metrics' # 0 () ()
 require_relative 'quark/concurrent' # 0 ('quark',) ()
 require_relative 'mdk_introspection' # 0 () ()
 require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
@@ -549,7 +550,7 @@ Session.unlazy_statics
 
 def self.MDKImpl; MDKImpl; end
 class MDKImpl < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :logger, :_reflection_hack, :_runtime, :_wsclient, :_openclose, :_disco, :_discoSource, :_tracer, :procUUID, :_running, :_defaultTimeout
+    attr_accessor :logger, :_reflection_hack, :_runtime, :_wsclient, :_openclose, :_disco, :_discoSource, :_tracer, :_metrics, :procUUID, :_running, :_defaultTimeout
     extend ::DatawireQuarkCore::Static
 
     static mdk_MDKImpl_ref: -> { nil }
@@ -566,10 +567,13 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if (!((runtime).dependencies.hasService("failurepolicy_factory")))
             (runtime).dependencies.registerService("failurepolicy_factory", self.getFailurePolicy(runtime))
         end
+        if ((runtime).dependencies.hasService("tracer"))
+            @_tracer = ::DatawireQuarkCore.cast((@_runtime).dependencies.getService("tracer")) { ::Quark.mdk_tracing.Tracer }
+        end
         @_disco = ::Quark.mdk_discovery.Discovery.new(runtime)
         @_wsclient = self.getWSClient(runtime)
         if ((@_wsclient) != (nil))
-            @_openclose = ::Quark.mdk_protocol.OpenCloseSubscriber.new(@_wsclient)
+            @_openclose = ::Quark.mdk_protocol.OpenCloseSubscriber.new(@_wsclient, @procUUID)
         end
         env = runtime.getEnvVarsService()
         discoFactory = self.getDiscoveryFactory(env)
@@ -578,8 +582,10 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
             (runtime).dependencies.registerService("discovery_registrar", @_discoSource)
         end
         if ((@_wsclient) != (nil))
-            @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime, @_wsclient)
-            @_tracer.initContext()
+            if ((@_tracer) == (nil))
+                @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime, @_wsclient)
+            end
+            @_metrics = ::Quark.mdk_metrics.MetricsClient.new(@_wsclient)
         end
 
         nil
@@ -668,6 +674,7 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
             (@_runtime).dispatcher.startActor(@_wsclient)
             (@_runtime).dispatcher.startActor(@_openclose)
             (@_runtime).dispatcher.startActor(@_tracer)
+            (@_runtime).dispatcher.startActor(@_metrics)
         end
         (@_runtime).dispatcher.startActor(@_disco)
         (@_runtime).dispatcher.startActor(@_discoSource)
@@ -788,6 +795,9 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_tracer"))
             return (self)._tracer
         end
+        if ((name) == ("_metrics"))
+            return (self)._metrics
+        end
         if ((name) == ("procUUID"))
             return (self).procUUID
         end
@@ -828,6 +838,9 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_tracer"))
             (self)._tracer = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.Tracer }
         end
+        if ((name) == ("_metrics"))
+            (self)._metrics = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_metrics.MetricsClient }
+        end
         if ((name) == ("procUUID"))
             (self).procUUID = ::DatawireQuarkCore.cast(value) { ::String }
         end
@@ -851,6 +864,7 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         self._disco = nil
         self._discoSource = nil
         self._tracer = nil
+        self._metrics = nil
         self.procUUID = ::Quark.quark.concurrent.Context.runtime().uuid()
         self._running = false
         self._defaultTimeout = nil
@@ -919,7 +933,7 @@ TLSInit.unlazy_statics
 
 def self.SessionImpl; SessionImpl; end
 class SessionImpl < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :_mdk, :_resolved, :_context, :_experimental
+    attr_accessor :_mdk, :_resolved, :_interactionReports, :_context, :_experimental
     extend ::DatawireQuarkCore::Static
 
     static _levels: -> { {"CRITICAL" => 0, "ERROR" => 1, "WARN" => 2, "INFO" => 3, "DEBUG" => 4} }
@@ -927,6 +941,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     static mdk_SessionImpl_ref: -> { nil }
     static quark_List_quark_List_mdk_discovery_Node___ref: -> { nil }
     static quark_List_mdk_discovery_Node__ref: -> { nil }
+    static quark_List_mdk_metrics_InteractionEvent__ref: -> { nil }
     static quark_List_quark_Map_quark_String_quark_String___ref: -> { nil }
     static quark_List_quark_String__ref: -> { nil }
     static quark_Map_quark_String_quark_int__ref: -> { nil }
@@ -947,6 +962,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
             ctx = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
             @_context = ctx.start_span()
         end
+        self.start_interaction()
 
         nil
     end
@@ -1064,8 +1080,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
                 return
             end
             ::Quark.mdk.SessionImpl._inLogging.setValue(true)
-            (@_mdk)._tracer.setContext(@_context)
-            (@_mdk)._tracer.log((@_mdk).procUUID, level, category, text)
+            (@_mdk)._tracer.log(@_context, (@_mdk).procUUID, level, category, text)
             ::Quark.mdk.SessionImpl._inLogging.setValue(false)
         end
 
@@ -1183,6 +1198,11 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def start_interaction()
         
+        interactionReport = ::Quark.mdk_metrics.InteractionEvent.new()
+        (interactionReport).node = (@_mdk).procUUID
+        (interactionReport).timestamp = ((1000.0) * ((@_mdk)._runtime.getTimeService().time())).round()
+        (interactionReport).session = (@_context).traceId
+        (@_interactionReports) << (interactionReport)
         (@_resolved) << (::DatawireQuarkCore::List.new([]))
 
         nil
@@ -1215,6 +1235,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
             idx = (idx) + (1)
             (involved) << (node.toString())
             node.failure()
+            (@_interactionReports)[((@_interactionReports).size) - (1)].addNode(node, false)
         end
         text = ((("involved: ") + ((involved).join(", "))) + ("\n\n")) + (message)
         self.error("interaction failure", text)
@@ -1226,12 +1247,17 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         
         nodes = self._current_interaction()
         (@_resolved).delete_at(((@_resolved).size) - (1))
+        report = (@_interactionReports).delete_at(((@_interactionReports).size) - (1))
         idx = 0
         while ((idx) < ((nodes).size)) do
             node = (nodes)[idx]
             node.success()
+            report.addNode(node, true)
             idx = (idx) + (1)
         end
+        if (((@_mdk)._metrics) != (nil))
+            (@_mdk)._metrics.sendInteraction(report)
+        end
 
         nil
     end
@@ -1266,6 +1292,9 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_resolved"))
             return (self)._resolved
         end
+        if ((name) == ("_interactionReports"))
+            return (self)._interactionReports
+        end
         if ((name) == ("_context"))
             return (self)._context
         end
@@ -1291,6 +1320,9 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_resolved"))
             (self)._resolved = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
         end
+        if ((name) == ("_interactionReports"))
+            (self)._interactionReports = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
         if ((name) == ("_context"))
             (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SharedContext }
         end
@@ -1304,7 +1336,8 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def __init_fields__()
         
         self._mdk = nil
-        self._resolved = ::DatawireQuarkCore::List.new([::DatawireQuarkCore::List.new([])])
+        self._resolved = ::DatawireQuarkCore::List.new([])
+        self._interactionReports = ::DatawireQuarkCore::List.new([])
         self._context = nil
         self._experimental = false
 

data/lib/mdk_discovery.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_discovery/protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_discovery/synapse.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_introspection.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_introspection/aws.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_introspection/kubernetes.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_metrics.rb

@@ -0,0 +1,333 @@
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
+module Quark
+require "quark"
+def self.mdk_metrics; MdkMetrics; end
+module MdkMetrics
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'mdk_protocol' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'mdk_discovery' # 0 () ()
+require_relative 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
+
+
+def self.InteractionEvent; InteractionEvent; end
+##
+# Wire protocol message for reporting interaction results to MCP.
+
+class InteractionEvent < ::Quark.mdk_protocol.Serializable
+    attr_accessor :timestamp, :uuid, :session, :node, :results
+    extend ::DatawireQuarkCore::Static
+
+    static _json_type: -> { "interaction_event" }
+    static mdk_metrics_InteractionEvent_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def getTimestamp()
+        
+        return (self).timestamp
+
+        nil
+    end
+
+    ##
+    # Add the result of communicating with a specific node.
+
+    def addNode(destination, success)
+        
+        value = 0
+        if (success)
+            value = 1
+        end
+        ((self).results)[::DatawireQuarkCore.cast(((destination).properties)["datawire_nodeId"]) { ::String }] = (value)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_metrics.InteractionEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_metrics.InteractionEvent._json_type
+        end
+        if ((name) == ("timestamp"))
+            return (self).timestamp
+        end
+        if ((name) == ("uuid"))
+            return (self).uuid
+        end
+        if ((name) == ("session"))
+            return (self).session
+        end
+        if ((name) == ("node"))
+            return (self).node
+        end
+        if ((name) == ("results"))
+            return (self).results
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_metrics.InteractionEvent._json_type = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("timestamp"))
+            (self).timestamp = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("uuid"))
+            (self).uuid = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("session"))
+            (self).session = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("results"))
+            (self).results = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.timestamp = nil
+        self.uuid = ::Quark.quark.concurrent.Context.runtime().uuid()
+        self.session = nil
+        self.node = nil
+        self.results = {}
+
+        nil
+    end
+
+
+end
+InteractionEvent.unlazy_statics
+
+def self.InteractionAck; InteractionAck; end
+##
+# Wire protocol message for MCP to acknowledge InteractionEvent receipt.
+
+class InteractionAck < ::Quark.mdk_protocol.Serializable
+    attr_accessor :sequence
+    extend ::DatawireQuarkCore::Static
+
+    static _json_type: -> { "interaction_ack" }
+    static mdk_metrics_InteractionAck_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_metrics.InteractionAck"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_metrics.InteractionAck._json_type
+        end
+        if ((name) == ("sequence"))
+            return (self).sequence
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_metrics.InteractionAck._json_type = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("sequence"))
+            (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.sequence = nil
+
+        nil
+    end
+
+
+end
+InteractionAck.unlazy_statics
+
+def self.MetricsClient; MetricsClient; end
+##
+# Mini-protocol for sending metrics to MCP.
+
+class MetricsClient < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_dispatcher, :_sock, :_sendWithAcks
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_metrics_MetricsClient_ref: -> { nil }
+
+
+
+    def initialize(wsclient)
+        
+        self.__init_fields__
+        wsclient.subscribe(self)
+
+        nil
+    end
+
+
+
+
+    ##
+    # Queue info about interaction to be sent to the MCP.
+
+    def sendInteraction(evt)
+        
+        (self)._sendWithAcks.send(::Quark.mdk_metrics.InteractionEvent._json_type, evt)
+
+        nil
+    end
+
+    def onStart(dispatcher)
+        
+        (self)._dispatcher = dispatcher
+
+        nil
+    end
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        ::Quark.mdk_protocol._subscriberDispatch(self, message)
+
+        nil
+    end
+
+    def onWSConnected(websock)
+        
+        (self)._sock = websock
+        (self)._sendWithAcks.onConnected(self, (self)._dispatcher, websock)
+
+        nil
+    end
+
+    def onPump()
+        
+        (self)._sendWithAcks.onPump(self, (self)._dispatcher, (self)._sock)
+
+        nil
+    end
+
+    def onMessageFromServer(message)
+        
+        type = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((type) == ("metrics.InteractionAck"))
+            ack = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_metrics.InteractionAck }
+            (self)._sendWithAcks.onAck((ack).sequence)
+            return
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_metrics.MetricsClient"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_dispatcher"))
+            return (self)._dispatcher
+        end
+        if ((name) == ("_sock"))
+            return (self)._sock
+        end
+        if ((name) == ("_sendWithAcks"))
+            return (self)._sendWithAcks
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_dispatcher"))
+            (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("_sock"))
+            (self)._sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("_sendWithAcks"))
+            (self)._sendWithAcks = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SendWithAcks }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._dispatcher = nil
+        self._sock = nil
+        self._sendWithAcks = ::Quark.mdk_protocol.SendWithAcks.new()
+
+        nil
+    end
+
+
+end
+MetricsClient.unlazy_statics
+
+
+require_relative 'datawire_mdk_md' # 0 () ()
+
+end # module MdkMetrics
+end # module Quark