AF-1541 additional timing granularity

example/panel/modules/data_load_async_module.dart

@@ -27,12 +27,14 @@ class DataLoadAsyncModule extends Module {
 
   DataLoadAsyncActions _actions;
   DataLoadAsyncComponents _components;
-  DataLoadAsyncStore _stores;
+  DataLoadAsyncEvents _events;
+  DataLoadAsyncStore _store;
 
   DataLoadAsyncModule() {
     _actions = new DataLoadAsyncActions();
-    _stores = new DataLoadAsyncStore(_actions);
-    _components = new DataLoadAsyncComponents(_actions, _stores);
+    _events = new DataLoadAsyncEvents();
+    _store = new DataLoadAsyncStore(_actions, _events);
+    _components = new DataLoadAsyncComponents(_actions, _store);
   }
 
   @override
@@ -42,8 +44,10 @@ class DataLoadAsyncModule extends Module {
   @protected
   Future<Null> onLoad() {
     // trigger non-blocking async load of data
+    _events.didLoadData.first
+        .then((_) => specifyStartupTiming(StartupTimingSpecifier.firstUseful));
     _actions.loadData();
-    return new Future.value();
+    return null;
   }
 }
 
@@ -62,15 +66,20 @@ class DataLoadAsyncActions {
   final Action loadData = new Action();
 }
 
+DispatchKey _dispatchKey = new DispatchKey('DataLoadAsync');
+
+class DataLoadAsyncEvents {
+  final Event didLoadData = new Event(_dispatchKey);
+}
+
 class DataLoadAsyncStore extends Store {
   DataLoadAsyncActions _actions;
-  List<String> _data;
-  bool _isLoading;
+  DataLoadAsyncEvents _events;
+  List<String> _data = [];
+  bool _isLoading = false;
 
-  DataLoadAsyncStore(this._actions) {
-    _isLoading = false;
-    _data = [];
-    triggerOnAction(_actions.loadData, _loadData);
+  DataLoadAsyncStore(this._actions, this._events) {
+    manageActionSubscription(_actions.loadData.listen(_loadData));
   }
 
   /// Public data
@@ -89,6 +98,8 @@ class DataLoadAsyncStore extends Store {
     // trigger on return of final data
     _data = ['Aaron', 'Dustin', 'Evan', 'Jay', 'Max', 'Trent'];
     _isLoading = false;
+    _events.didLoadData(null, _dispatchKey);
+    trigger();
   }
 }
 

example/panel/modules/sample_tracer.dart

@@ -0,0 +1,162 @@
+import 'dart:async';
+import 'package:opentracing/opentracing.dart';
+
+class SampleSpan implements Span {
+  static int _nextId = 0;
+  final int _id = _nextId++;
+
+  @override
+  final List<Reference> references;
+
+  @override
+  final Map<String, dynamic> tags;
+
+  @override
+  final List<LogData> logData = [];
+
+  @override
+  final String operationName;
+
+  @override
+  SpanContext context;
+
+  @override
+  final DateTime startTime;
+  DateTime _endTime;
+
+  Completer<Span> _whenFinished = new Completer<Span>();
+
+  SampleSpan(
+    this.operationName, {
+    SpanContext childOf,
+    this.references,
+    DateTime startTime,
+    Map<String, dynamic> tags,
+  })
+      : this.startTime = startTime ?? new DateTime.now(),
+        this.tags = tags ?? {} {
+    if (childOf != null) {
+      references.add(new Reference.childOf(childOf));
+    }
+    setTag('span.kind', 'client');
+
+    final parent = parentContext;
+    if (parent != null) {
+      this.context = new SpanContext(spanId: _id, traceId: parent.traceId);
+      this.context.baggage.addAll(parent.baggage);
+    } else {
+      this.context = new SpanContext(spanId: _id, traceId: _id);
+    }
+  }
+
+  @override
+  void addTags(Map<String, dynamic> newTags) => tags.addAll(newTags);
+
+  @override
+  Duration get duration => _endTime?.difference(startTime);
+
+  @override
+  DateTime get endTime => _endTime;
+
+  @override
+  void finish({DateTime finishTime}) {
+    if (_whenFinished == null) {
+      return;
+    }
+
+    _endTime = finishTime ?? new DateTime.now();
+    _whenFinished.complete(this);
+    _whenFinished = null;
+  }
+
+  @override
+  void log(String event, {dynamic payload, DateTime timestamp}) =>
+      logData.add(new LogData(timestamp ?? new DateTime.now(), event, payload));
+
+  @override
+  SpanContext get parentContext =>
+      references.isEmpty ? null : references.first.referencedContext;
+
+  @override
+  void setTag(String tagName, dynamic value) => tags[tagName] = value;
+
+  @override
+  Future<Span> get whenFinished => _whenFinished.future;
+
+  @override
+  String toString() {
+    final sb = new StringBuffer('SampleSpan(');
+    sb
+      ..writeln('traceId: ${context.traceId}')
+      ..writeln('spanId: ${context.spanId}')
+      ..writeln('operationName: $operationName')
+      ..writeln('tags: ${tags.toString()}')
+      ..writeln('startTime: ${startTime.toString()}');
+
+    if (_endTime != null) {
+      sb
+        ..writeln('endTime: ${endTime.toString()}')
+        ..writeln('duration: ${duration.toString()}');
+    }
+
+    if (logData.isNotEmpty) {
+      sb.writeln('logData: ${logData.toString()}');
+    }
+
+    if (references.isNotEmpty) {
+      final reference = references.first;
+      sb.writeln(
+          'reference: ${reference.referenceType} ${reference.referencedContext.spanId}');
+    }
+
+    sb.writeln(')');
+
+    return sb.toString();
+  }
+}
+
+class SampleTracer implements AbstractTracer {
+  @override
+  SampleSpan startSpan(
+    String operationName, {
+    SpanContext childOf,
+    List<Reference> references,
+    DateTime startTime,
+    Map<String, dynamic> tags,
+  }) {
+    return new SampleSpan(
+      operationName,
+      childOf: childOf,
+      references: references,
+      startTime: startTime,
+      tags: tags,
+    )
+      ..whenFinished.then((span) {
+        print(span.toString());
+      });
+  }
+
+  @override
+  Reference childOf(SpanContext context) => new Reference.childOf(context);
+
+  @override
+  Reference followsFrom(SpanContext context) =>
+      new Reference.followsFrom(context);
+
+  @override
+  SpanContext extract(String format, dynamic carrier) {
+    throw new UnimplementedError(
+        'Sample tracer for example purposes does not support advanced tracing behavior.');
+  }
+
+  @override
+  void inject(SpanContext spanContext, String format, dynamic carrier) {
+    throw new UnimplementedError(
+        'Sample tracer for example purposes does not support advanced tracing behavior.');
+  }
+
+  @override
+  Future<dynamic> flush() {
+    return null;
+  }
+}

example/panel/panel_app.dart

@@ -22,13 +22,19 @@ import 'package:platform_detect/platform_detect.dart';
 import 'package:react/react_dom.dart' as react_dom;
 import 'package:react/react_client.dart' as react_client;
 import 'package:w_module/w_module.dart' hide Event;
+import 'package:opentracing/opentracing.dart';
 
 import 'modules/panel_module.dart';
+import 'modules/sample_tracer.dart';
 
 Future<Null> main() async {
   Element container = querySelector('#panel-container');
   react_client.setClientConfiguration();
 
+  final tracer = new SampleTracer();
+  initGlobalTracer(tracer);
+  assert(globalTracer() == tracer);
+
   // instantiate the core app module and wait for it to complete loading
   PanelModule panelModule = new PanelModule();
   await panelModule.load();