Span applicability to Drop impl

[sukhmel]

I'm struggling a bit to build a minimal reproduction, but I hope the question will be clear enough without that. I've got a stream that I give to gRPC call, and a resultant stream from gRPC. I want to record some data and log it once both streams are completed, so I made a naïve implementation that has a recorder in Arc<Mutex< …>> and then call inspect(…) on both streams, something like:

    impl Drop for Recorder {
        fn drop(&mut self) {
            info!("{self:?}");
        }
    }

    async fn connect(…) -> Result<BoxStream<'static, CallResult>, Status> {
        let recorder = Arc::new(Mutex::new(Recorder::new()));
        let request = Request::new(
            ReceiverStream::new(rx)
                .inspect(move |req| {
                    if let Ok(mut recorder) = recorder.lock() {
                        recorder.request(req)
                    };
                }),
        );
        
        Ok(grpc_client
            .rpc_call(request)
            .await?
            .into_inner()
            .inspect(move |result| {
                if let Ok(mut recorder) = recorder.lock() {
                    recorder.response(&result)
                }
            })
            .boxed())
    }

I was not sure if an outer span will be correctly applied, the function two calls higher was instrumented with a span if that's important. It appears, the call to drop(…) gets instrumented sometimes.

For now I've tried to pass a weak reference to the outgoing stream and keep the original Arc in the incoming stream, it works but I expect this to be a bit of a race condition, as I can call upgrade on a weak reference just before the main reference is dropped. Besides, this doesn't really explain how should I reason about what span is applied to the log in drop(…)

So, I have two questions, really:

1. How should I make sure that a drop gets instrumented? If that's really possible
2. What is the correct way to make sure an object is not dropped by weak reference? I'm guessing, this is off-topic here, but since it's related to the issue I have and I wasn't able to find anything in other places, I'll still try asking here

[mladedav]

So when you're dealing with Arc, you can't really be sure where the drop will happen. It depends on where it is last observed. So I think instrumentation will depend on that.

Also note that the drop order matters. If you enter a spam and are holding a guard, if the guard is dropped before your Arc, it will not be instrumented. If the Arc is dropped first, it will be instrumented.

The best way to make sure is to use span.in_scope, then you can be sure that all drops will happen in the span's context. Or dropping things explicitly. This does not help you on its own with Arcs though, you need to make sure that all drops are correctly instrumented.

I don't understand your second question. Weak cannot drop the inner object. When the last Arc is dropped, the object is dropped regardless of how many Weaks there still are.

[sukhmel]

Regarding the second question: when I upgrade Weak it's just another Arc if an upgrade is successful. It will keep the Arc alive even after every other reference is dead.

Regarding the first: so it seems that the best bet is to make a span: Span field in the struct and fill it with Span::current() to later use upon drop, is it?

[mladedav]

Right, if you can carry the span around, that's the way to go to make sure it's in that span.

Right, once you upgrade a Weak into an Arc, that Arc also contributes to the strong count. But if you then drop all the other Arcs and then drop this Arc, the object will be deallocated regardless of whether you still hold the Weak or not. It doesn't really matter whether the Arcs come from cloning or upgrading, once the last one is dropped, then the object is deallocated and you won't be able to upgrade any more Weaks.