fix(subscriber): ignore exiting spans that were never entered

Similarly, if we don't record entering a span due to event buffer
capacity, it doesn't make sense to record exiting it. This commit
changes the `ConsoleLayer` to only push a span to the current thread's
span stack if we were able to successfully send an `Enter` event to the
aggregator. This means that it won't be considered the parent span for
other events/spans. When a span is exited, we only send an `Exit` event
to the aggregator if the span *was* previously recorded as being entered.

In theory, ignoring subsequent events on spans that were dropped due to
buffer capacity technically means we are losing *more* data than we
would have if we did not ignore those spans. But, the data we are losing
here is *wrong*. For example, we cannot calculate a correct poll time
for a poll where we didn't record the beginning of the poll, and we only
recorded the poll ending. Therefore, I think it's better to ignore this
data than to make a half-assed attempt to record it even though we know
it's incorrect.

I believe this will probably also fix issue #180. That issue occurs
when we attempt to decrement the number of times a task has been
polled, and sometimes --- if an `enter` event for that task was missed
--- we may subtract more than we've added to the counter. By ignoring
exits for spans that we never recorded as entered, this panic should now
be avoided.

Author: hawkw

console-subscriber/src/lib.rs

@@ -721,20 +721,24 @@ where
             return;
         }
         let _default = dispatcher::set_default(&self.no_dispatch);
-        self.current_spans
-            .get_or_default()
-            .borrow_mut()
-            .push(id.clone());
-
         let parent_id = cx.span(id).and_then(|s| s.parent().map(|p| p.id()));
-        self.send(
+        let sent = self.send(
             &self.shared.dropped_tasks,
             Event::Enter {
                 at: SystemTime::now(),
                 id: id.clone(),
                 parent_id,
             },
         );
+
+        // if we were able to record the send successfully, track entering the
+        // span. if not, ignore the enter, to avoid inconsistent data.
+        if sent {
+            self.current_spans
+                .get_or_default()
+                .borrow_mut()
+                .push(id.clone());
+        }
     }
 
     fn on_exit(&self, id: &span::Id, cx: Context<'_, S>) {
@@ -744,7 +748,12 @@ where
 
         let _default = dispatcher::set_default(&self.no_dispatch);
         if let Some(spans) = self.current_spans.get() {
-            spans.borrow_mut().pop(id);
+            if !spans.borrow_mut().pop(id) {
+                // we did not actually pop the span --- entering it may not have
+                // been successfully recorded. in this case, ignore the exit,
+                // since the aggregator was never informed of the entry.
+                return;
+            }
         }
 
         let parent_id = cx.span(id).and_then(|s| s.parent().map(|p| p.id()));

console-subscriber/src/stack.rs

@@ -34,6 +34,9 @@ impl SpanStack {
         !duplicate
     }
 
+    /// Pop a currently entered span.
+    ///
+    /// Returns `true` if the span was actually exited.
     #[inline]
     pub(crate) fn pop(&mut self, expected_id: &Id) -> bool {
         if let Some((idx, _)) = self