datawire_mdk 2.0.22 → 2.0.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_runtime; MdkRuntime; end
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_runtime; MdkRuntime; end
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_runtime; MdkRuntime; end
data/lib/mdk_tracing.rb CHANGED
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_tracing; MdkTracing; end
@@ -7,18 +7,61 @@ require "datawire-quark-core"
7
7
  require_relative 'quark/reflect' # 0 ('quark',) ()
8
8
  require_relative 'mdk_tracing/api' # 0 ('mdk_tracing',) ()
9
9
  require_relative 'mdk_tracing/protocol' # 0 ('mdk_tracing',) ()
10
- require_relative 'mdk_protocol' # 0 () ()
11
10
  require_relative 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
11
+ require_relative 'mdk_protocol' # 0 () ()
12
12
  require_relative 'quark' # 0 () ()
13
13
  require_relative 'mdk_runtime' # 0 () ()
14
14
  require_relative 'mdk_rtp' # 0 () ()
15
15
 
16
16
 
17
- def self.SharedContextInitializer; SharedContextInitializer; end
18
- class SharedContextInitializer < ::DatawireQuarkCore::QuarkObject
17
+ def self.TracingDestination; TracingDestination; end
18
+ ##
19
+ # MDK can use this to handle logging on the Session.
20
+
21
+ class TracingDestination < ::DatawireQuarkCore::QuarkObject
22
+ extend ::DatawireQuarkCore::Static
23
+
24
+ static mdk_tracing_TracingDestination_ref: -> { nil }
25
+
26
+
27
+
28
+ def initialize()
29
+ self.__init_fields__
30
+
31
+ nil
32
+ end
33
+
34
+
35
+
36
+
37
+ ##
38
+ # Send a log message to the server.
39
+
40
+ def log(ctx, procUUID, level, category, text)
41
+ raise NotImplementedError, '`TracingDestination.log` is an abstract method'
42
+
43
+ nil
44
+ end
45
+
46
+ def __init_fields__()
47
+
48
+
49
+ nil
50
+ end
51
+
52
+
53
+ end
54
+ TracingDestination.unlazy_statics
55
+
56
+ def self.FakeTracer; FakeTracer; end
57
+ ##
58
+ # In-memory testing of logs.
59
+
60
+ class FakeTracer < ::DatawireQuarkCore::QuarkObject
61
+ attr_accessor :messages
19
62
  extend ::DatawireQuarkCore::Static
20
63
 
21
- static mdk_tracing_SharedContextInitializer_ref: -> { nil }
64
+ static mdk_tracing_FakeTracer_ref: -> { nil }
22
65
 
23
66
 
24
67
 
@@ -31,22 +74,46 @@ class SharedContextInitializer < ::DatawireQuarkCore::QuarkObject
31
74
 
32
75
 
33
76
 
34
- def getValue()
77
+ def log(ctx, procUUID, level, category, text)
78
+
79
+ (@messages) << ({"level" => level, "category" => category, "text" => text, "context" => (ctx).traceId})
80
+
81
+ nil
82
+ end
83
+
84
+ def onStart(dispatcher)
85
+
86
+ nil
87
+
88
+ nil
89
+ end
90
+
91
+ def onStop()
35
92
 
36
- return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.SharedContext }
93
+ nil
94
+
95
+ nil
96
+ end
97
+
98
+ def onMessage(origin, message)
99
+
100
+ nil
37
101
 
38
102
  nil
39
103
  end
40
104
 
41
105
  def _getClass()
42
106
 
43
- return "mdk_tracing.SharedContextInitializer"
107
+ return "mdk_tracing.FakeTracer"
44
108
 
45
109
  nil
46
110
  end
47
111
 
48
112
  def _getField(name)
49
113
 
114
+ if ((name) == ("messages"))
115
+ return (self).messages
116
+ end
50
117
  return nil
51
118
 
52
119
  nil
@@ -54,24 +121,30 @@ class SharedContextInitializer < ::DatawireQuarkCore::QuarkObject
54
121
 
55
122
  def _setField(name, value)
56
123
 
57
- nil
124
+ if ((name) == ("messages"))
125
+ (self).messages = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
126
+ end
58
127
 
59
128
  nil
60
129
  end
61
130
 
62
131
  def __init_fields__()
63
132
 
133
+ self.messages = ::DatawireQuarkCore::List.new([])
64
134
 
65
135
  nil
66
136
  end
67
137
 
68
138
 
69
139
  end
70
- SharedContextInitializer.unlazy_statics
140
+ FakeTracer.unlazy_statics
71
141
 
72
142
  def self.Tracer; Tracer; end
143
+ ##
144
+ # Send log messages to the MCP server.
145
+
73
146
  class Tracer < ::DatawireQuarkCore::QuarkObject
74
- attr_accessor :logger, :lastPoll, :_context, :_client, :runtime
147
+ attr_accessor :logger, :lastPoll, :_client, :runtime
75
148
  extend ::DatawireQuarkCore::Static
76
149
 
77
150
  static mdk_tracing_Tracer_ref: -> { nil }
@@ -133,62 +206,11 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
133
206
  nil
134
207
  end
135
208
 
136
- def initContext()
137
-
138
- @_context.setValue(::Quark.mdk_protocol.SharedContext.new())
139
-
140
- nil
141
- end
142
-
143
- def joinContext(context)
144
-
145
- @_context.setValue(context.start_span())
146
-
147
- nil
148
- end
149
-
150
- def joinEncodedContext(encodedContext)
151
-
152
- newContext = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
153
- self.joinContext(newContext)
154
-
155
- nil
156
- end
157
-
158
- def getContext()
159
-
160
- return @_context.getValue()
161
-
162
- nil
163
- end
164
-
165
- def setContext(ctx)
166
-
167
- @_context.setValue(ctx)
168
-
169
- nil
170
- end
171
-
172
- def start_span()
173
-
174
- @_context.setValue(self.getContext().start_span())
175
-
176
- nil
177
- end
178
-
179
- def finish_span()
180
-
181
- @_context.setValue(self.getContext().finish_span())
182
-
183
- nil
184
- end
185
-
186
209
  ##
187
210
  # Send a log message to the server.
188
211
 
189
- def log(procUUID, level, category, text)
212
+ def log(ctx, procUUID, level, category, text)
190
213
 
191
- ctx = self.getContext()
192
214
  ctx.tick()
193
215
  @logger.trace(("CTX ") + (ctx.toString()))
194
216
  evt = ::Quark.mdk_tracing.protocol.LogEvent.new()
@@ -226,9 +248,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
226
248
  if ((name) == ("lastPoll"))
227
249
  return (self).lastPoll
228
250
  end
229
- if ((name) == ("_context"))
230
- return (self)._context
231
- end
232
251
  if ((name) == ("_client"))
233
252
  return (self)._client
234
253
  end
@@ -248,9 +267,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
248
267
  if ((name) == ("lastPoll"))
249
268
  (self).lastPoll = ::DatawireQuarkCore.cast(value) { ::Integer }
250
269
  end
251
- if ((name) == ("_context"))
252
- (self)._context = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
253
- end
254
270
  if ((name) == ("_client"))
255
271
  (self)._client = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.protocol.TracingClient }
256
272
  end
@@ -265,7 +281,6 @@ class Tracer < ::DatawireQuarkCore::QuarkObject
265
281
 
266
282
  self.logger = ::Quark.quark._getLogger("MDK Tracer")
267
283
  self.lastPoll = 0
268
- self._context = ::DatawireQuarkCore::TLS.new(::Quark.mdk_tracing.SharedContextInitializer.new())
269
284
  self._client = nil
270
285
  self.runtime = nil
271
286
 
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_tracing; MdkTracing; end
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_tracing; MdkTracing; end
@@ -15,7 +15,7 @@ require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_tracing',)
15
15
 
16
16
  def self.LogEvent; LogEvent; end
17
17
  class LogEvent < ::Quark.mdk_protocol.Serializable
18
- attr_accessor :context, :timestamp, :node, :level, :category, :contentType, :text, :sequence, :sync
18
+ attr_accessor :context, :timestamp, :node, :level, :category, :contentType, :text
19
19
  extend ::DatawireQuarkCore::Static
20
20
 
21
21
  static _json_type: -> { "log" }
@@ -33,9 +33,16 @@ class LogEvent < ::Quark.mdk_protocol.Serializable
33
33
 
34
34
 
35
35
 
36
+ def getTimestamp()
37
+
38
+ return (self).timestamp
39
+
40
+ nil
41
+ end
42
+
36
43
  def toString()
37
44
 
38
- return (((((((((((((((("<LogEvent ") + ((@sequence).to_s)) + (" @")) + ((@timestamp).to_s)) + (" ")) + (@context.toString())) + (", ")) + (@node)) + (", ")) + (@level)) + (", ")) + (@category)) + (", ")) + (@contentType)) + (", ")) + (@text)) + (">")
45
+ return (((((((((((((("<LogEvent ") + ((@timestamp).to_s)) + (" ")) + (@context.toString())) + (", ")) + (@node)) + (", ")) + (@level)) + (", ")) + (@category)) + (", ")) + (@contentType)) + (", ")) + (@text)) + (">")
39
46
 
40
47
  nil
41
48
  end
@@ -73,12 +80,6 @@ class LogEvent < ::Quark.mdk_protocol.Serializable
73
80
  if ((name) == ("text"))
74
81
  return (self).text
75
82
  end
76
- if ((name) == ("sequence"))
77
- return (self).sequence
78
- end
79
- if ((name) == ("sync"))
80
- return (self).sync
81
- end
82
83
  return nil
83
84
 
84
85
  nil
@@ -110,12 +111,6 @@ class LogEvent < ::Quark.mdk_protocol.Serializable
110
111
  if ((name) == ("text"))
111
112
  (self).text = ::DatawireQuarkCore.cast(value) { ::String }
112
113
  end
113
- if ((name) == ("sequence"))
114
- (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
115
- end
116
- if ((name) == ("sync"))
117
- (self).sync = ::DatawireQuarkCore.cast(value) { ::Integer }
118
- end
119
114
 
120
115
  nil
121
116
  end
@@ -130,8 +125,6 @@ class LogEvent < ::Quark.mdk_protocol.Serializable
130
125
  self.category = nil
131
126
  self.contentType = nil
132
127
  self.text = nil
133
- self.sequence = nil
134
- self.sync = nil
135
128
 
136
129
  nil
137
130
  end
@@ -276,7 +269,7 @@ LogAck.unlazy_statics
276
269
 
277
270
  def self.TracingClient; TracingClient; end
278
271
  class TracingClient < ::DatawireQuarkCore::QuarkObject
279
- attr_accessor :_tracer, :_started, :_mutex, :_handler, :_dispatcher, :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_logged, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_wsclient, :_sock, :_myLog
272
+ attr_accessor :_tracer, :_started, :_mutex, :_handler, :_dispatcher, :_wsclient, :_sock, :_sendWithAcks
280
273
  extend ::DatawireQuarkCore::Static
281
274
 
282
275
  static mdk_tracing_protocol_TracingClient_ref: -> { nil }
@@ -288,6 +281,7 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
288
281
  self.__init_fields__
289
282
  @_tracer = tracer
290
283
  @_wsclient = wsclient
284
+ @_sendWithAcks = ::Quark.mdk_protocol.SendWithAcks.new()
291
285
  wsclient.subscribe(self)
292
286
 
293
287
  nil
@@ -296,14 +290,6 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
296
290
 
297
291
 
298
292
 
299
- def _debug(message)
300
-
301
- s = (((("[") + (((@_buffered).size).to_s)) + (" buf, ")) + (((@_inFlight).size).to_s)) + (" inf] ")
302
- @_myLog.debug((s) + (message))
303
-
304
- nil
305
- end
306
-
307
293
  ##
308
294
  # Attach a subscriber that will receive results of queries.
309
295
 
@@ -341,13 +327,7 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
341
327
 
342
328
  @_mutex.acquire()
343
329
  (self)._sock = websock
344
- while (((@_inFlight).size) > (0)) do
345
- evt = (@_inFlight).delete_at(((@_inFlight).size) - (1))
346
- (@_buffered).insert((0), (evt))
347
- @_failedSends = (@_failedSends) + ((1))
348
- self._debug(("no ack for #") + (((evt).sequence).to_s))
349
- end
350
- self._debug(("Starting up! with connection ") + (((self)._sock).to_s))
330
+ (self)._sendWithAcks.onConnected(self, (self)._dispatcher, websock)
351
331
  if ((@_handler) != (nil))
352
332
  (self)._dispatcher.tell(self, ::Quark.mdk_tracing.protocol.Subscribe.new().encode(), (self)._sock)
353
333
  end
@@ -359,20 +339,7 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
359
339
  def onPump()
360
340
 
361
341
  @_mutex.acquire()
362
- while (((@_buffered).size) > (0)) do
363
- debugSuffix = ""
364
- evt = (@_buffered).delete_at(0)
365
- (@_inFlight) << (evt)
366
- if ((((evt).timestamp) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
367
- (evt).sync = 1
368
- @_lastSyncTime = (evt).timestamp
369
- debugSuffix = " with sync set"
370
- end
371
- (self)._dispatcher.tell(self, evt.encode(), (self)._sock)
372
- (evt).sync = 0
373
- @_sent = (@_sent) + ((1))
374
- self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + (((self)._sock).to_s))
375
- end
342
+ (self)._sendWithAcks.onPump(self, (self)._dispatcher, (self)._sock)
376
343
  @_mutex.release()
377
344
 
378
345
  nil
@@ -409,15 +376,7 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
409
376
  def onLogAck(ack)
410
377
 
411
378
  @_mutex.acquire()
412
- while (((@_inFlight).size) > (0)) do
413
- if ((((@_inFlight)[0]).sequence) <= ((ack).sequence))
414
- evt = (@_inFlight).delete_at(0)
415
- @_recorded = (@_recorded) + ((1))
416
- self._debug(((("ack #") + (((ack).sequence).to_s)) + (", discarding #")) + (((evt).sequence).to_s))
417
- else
418
- break
419
- end
420
- end
379
+ (self)._sendWithAcks.onAck((ack).sequence)
421
380
  @_mutex.release()
422
381
 
423
382
  nil
@@ -429,11 +388,7 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
429
388
  def log(evt)
430
389
 
431
390
  @_mutex.acquire()
432
- (evt).sequence = @_logged
433
- (evt).sync = 0
434
- @_logged = (@_logged) + ((1))
435
- (@_buffered) << (evt)
436
- self._debug(("logged #") + (((evt).sequence).to_s))
391
+ (self)._sendWithAcks.send(::Quark.mdk_tracing.protocol.LogEvent._json_type, evt)
437
392
  @_mutex.release()
438
393
 
439
394
  nil
@@ -463,41 +418,14 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
463
418
  if ((name) == ("_dispatcher"))
464
419
  return (self)._dispatcher
465
420
  end
466
- if ((name) == ("_syncRequestPeriod"))
467
- return (self)._syncRequestPeriod
468
- end
469
- if ((name) == ("_syncInFlightMax"))
470
- return (self)._syncInFlightMax
471
- end
472
- if ((name) == ("_buffered"))
473
- return (self)._buffered
474
- end
475
- if ((name) == ("_inFlight"))
476
- return (self)._inFlight
477
- end
478
- if ((name) == ("_logged"))
479
- return (self)._logged
480
- end
481
- if ((name) == ("_sent"))
482
- return (self)._sent
483
- end
484
- if ((name) == ("_failedSends"))
485
- return (self)._failedSends
486
- end
487
- if ((name) == ("_recorded"))
488
- return (self)._recorded
489
- end
490
- if ((name) == ("_lastSyncTime"))
491
- return (self)._lastSyncTime
492
- end
493
421
  if ((name) == ("_wsclient"))
494
422
  return (self)._wsclient
495
423
  end
496
424
  if ((name) == ("_sock"))
497
425
  return (self)._sock
498
426
  end
499
- if ((name) == ("_myLog"))
500
- return (self)._myLog
427
+ if ((name) == ("_sendWithAcks"))
428
+ return (self)._sendWithAcks
501
429
  end
502
430
  return nil
503
431
 
@@ -521,41 +449,14 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
521
449
  if ((name) == ("_dispatcher"))
522
450
  (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
523
451
  end
524
- if ((name) == ("_syncRequestPeriod"))
525
- (self)._syncRequestPeriod = ::DatawireQuarkCore.cast(value) { ::Integer }
526
- end
527
- if ((name) == ("_syncInFlightMax"))
528
- (self)._syncInFlightMax = ::DatawireQuarkCore.cast(value) { ::Integer }
529
- end
530
- if ((name) == ("_buffered"))
531
- (self)._buffered = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
532
- end
533
- if ((name) == ("_inFlight"))
534
- (self)._inFlight = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
535
- end
536
- if ((name) == ("_logged"))
537
- (self)._logged = ::DatawireQuarkCore.cast(value) { ::Integer }
538
- end
539
- if ((name) == ("_sent"))
540
- (self)._sent = ::DatawireQuarkCore.cast(value) { ::Integer }
541
- end
542
- if ((name) == ("_failedSends"))
543
- (self)._failedSends = ::DatawireQuarkCore.cast(value) { ::Integer }
544
- end
545
- if ((name) == ("_recorded"))
546
- (self)._recorded = ::DatawireQuarkCore.cast(value) { ::Integer }
547
- end
548
- if ((name) == ("_lastSyncTime"))
549
- (self)._lastSyncTime = ::DatawireQuarkCore.cast(value) { ::Integer }
550
- end
551
452
  if ((name) == ("_wsclient"))
552
453
  (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
553
454
  end
554
455
  if ((name) == ("_sock"))
555
456
  (self)._sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
556
457
  end
557
- if ((name) == ("_myLog"))
558
- (self)._myLog = value
458
+ if ((name) == ("_sendWithAcks"))
459
+ (self)._sendWithAcks = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SendWithAcks }
559
460
  end
560
461
 
561
462
  nil
@@ -568,18 +469,9 @@ class TracingClient < ::DatawireQuarkCore::QuarkObject
568
469
  self._mutex = ::DatawireQuarkCore::Lock.new()
569
470
  self._handler = nil
570
471
  self._dispatcher = nil
571
- self._syncRequestPeriod = 5000
572
- self._syncInFlightMax = 50
573
- self._buffered = ::DatawireQuarkCore::List.new([])
574
- self._inFlight = ::DatawireQuarkCore::List.new([])
575
- self._logged = 0
576
- self._sent = 0
577
- self._failedSends = 0
578
- self._recorded = 0
579
- self._lastSyncTime = 0
580
472
  self._wsclient = nil
581
473
  self._sock = nil
582
- self._myLog = ::Quark.quark._getLogger("TracingClient")
474
+ self._sendWithAcks = nil
583
475
 
584
476
  nil
585
477
  end