Event-driven and reactive systems

[robertvazan]

Event-driven and reactive systems

[jpkrohling]

Would you be able to provide some code and the current outcome, along with the expected outcome?

[robertvazan]

The code in question is a bit too lengthy and complicated to post here. Consider simple parent-child pair with callback being called inside the child:

class Parent {
    Child child = new Child();
    Parent() {
        // subscribe to events in child
    }
}
class Child {
    void someCallback() {
        Span span = GlobalTracer.get().buildSpan("Child.someCallback").start();
        try (Scope scope = GlobalTracer.get().activateSpan(span)) {
            // possibly propagate the event to parent via some listener
        }
    }
}

If the child callback doesn't propagate the event to parent, information about the parent will be completely omitted from the trace.

As a workaround, I have a helper class OwnerTrace that is used like this:

class Parent {
    Child child = OwnerTrace.of(new Child())
        .parent(this)
        .tag("key1", "value")
        .target();
    Parent() {
        OwnerTrace.of(this).tag("key2", "value");
        // subscribe to events in child
    }
}
class Child {
    Child() {
        OwnerTrace.of(this).tag("key3", "value");
    }
    void someCallback() {
        Span span = GlobalTracer.get().buildSpan("Child.someCallback").start();
        OwnerTrace.of(this).fill(span); // fills in key1, key2, key3
        try (Scope scope = GlobalTracer.get().activateSpan(span)) {
            // possibly propagate the event to parent via some listener
        }
    }
}

The key point is that OwnerTrace.parent() creates ownership hierarchy and OwnerTrace.fill() pulls tags from all ancestors.

There are many issues with this solution. The most basic one is that this is effectively a non-standard extension to opentracing that is not supported by anything and limits code sharing.

The above example is trivial and as such allows for many workarounds, but in practice I get ownership chains that are 5 levels deep, spanning several internal libraries, and child objects usually don't know anything about their current parent.