Best way to ensure Context is cleared from a pooled thread

[Azquelt]

If I'm using a thread pool, how should I best make sure that the Context from one task doesn't leak into the next task on the pooled thread if someone forgets to close a Scope somewhere?

For context I'm integrating OpenTelemetry with the Open Liberty application server, the user could deploy several applications to the server, all of which would use the same thread pool and each request would be served with a new task submitted to the thread pool.

If the user fails to close a Scope, I want to be able to ensure the related Context doesn't get used for a different request. I can also emit a warning suggesting they use the io.opentelemetry.context.enableStrictContext system property to find the location of the leak.

Options I'm currently considering

1. Call ContextStorage.current() before an after each task on the thread pool.

   • If the result is not the same then a Scope hasn't been closed.
   • I can ensure the context doesn't leak by calling Context.root().makeCurrent() and discarding the returned Scope
     • However, this will result in a further warning if enableStrictContext is enabled

2. Implement my own ContextStorage with an additional method to clear the current Context without creating a Scope

   • This would be almost identical to ThreadLocalContextStorage but with an extra method to clear the context
   • This is the only way I could see to change the current Context without generating a Scope
   • If enableStrictContext is enabled, I would also need a way of getting hold of my ContextStorage instance directly, since ContextStorage.current() would return the wrapping StrictContextStorage

Does anyone have any better suggestions or see any problems with either of these approaches?

Other notes

Before #5061 was merged in v1.22, if you forgot to close a scope but the parent scope was correctly closed, the current scope would be set back to what it was before the parent was created and the child wouldn't leak. (The downside of the previous behaviour was that you end up in all sorts of trouble if you close scopes in the wrong order or on the wrong thread.)

[jkwatson]

I think the best option is to force Context.root().makeCurrent() before handing out the thread to the user. Yes, there will be a warning when scopes are properly improperly closed, but this is exactly what you need to know. Not closing scopes can lead to very bad bugs, so knowing about it is quite important.

[Azquelt]

Yes, there will be a warning when scopes are properly closed

From the rest of the answer, I think this should be "improperly closed"?

In that case then yes, I think that works. I make the root context current before each task and then close the resulting scope at the end. If everything is done properly there should be no warnings, and if a scope wasn't closed somewhere then the current context will be different when the task ends and we can detect that and warn.

[jkwatson]

sorry, yes. typo!