Add example for actix-web framework

[oriontvv]

Hi guys, thanks for your contribution!

There is an issue with using the client with actix-web framework.
Because Registry doesn't implement Copy - the only working solution I've found is to wrap it with Mutex. But it requires locking at least on each collecting of metrics which isn't good for performance. Are there any other suggestions?

[mxinden]

Because Registry doesn't implement Copy

I think you are confusing Copy and Clone.

Differs from Copy in that Copy is implicit and an inexpensive bit-wise copy, while Clone is always explicit and may or may not be expensive. In order to enforce these characteristics, Rust does not allow you to reimplement Copy, but you may reimplement Clone and run arbitrary code.

https://doc.rust-lang.org/std/clone/trait.Clone.html

I think a good rule of thumb whether a type should implement Clone is whether it fits into a single CPU cache line. This is not the case for Registry, i.e. Registry even spills to the heap.

the only working solution I've found is to wrap it with Mutex. But it requires locking at least on each collecting of metrics which isn't good for performance.

First I would like to question "isn't good for performance". In case this is happening mostly on a single core, memory synchronization costs are likely low. Asked from a different perspective, how would you like to share an object between concurrent executions without some mechanism of synchronization? We could invent some lock-free / wait-free mechanism, though I doubt that is worth the effort (see below). This is a serious question. Happy for suggestions.

To dive a bit deeper into the matter of performance here, the lock only enforces mutual exclusion on the metric collection path. I would expect this path to never be a bottleneck on your end. In other words I would not expect more than ~1 scrape per second. Note that metric recording can happen concurrently.

Let me know if the above is of some help @oriontvv.

[oriontvv]

@mxinden Hi, thanks for the feedback and sorry for late reply.
Yes, you are absolutely right - Registry doesn't implement Clone, my mistake, thanks.

Asked from a different perspective, how would you like to share an object between concurrent executions without some mechanism of synchronization? We could invent some lock-free / wait-free mechanism, though I doubt that is worth the effort (see below). This is a serious question. Happy for suggestions.

About the question - I thought that it's possible to avoid blocking like an example for tide do(I don't see any blocking for State)
But Arc can't be used with actix-web(or I do something wrong) - compiler says that:

let registry: Arc<Registry> = Arc::new(Registry::default());
HttpServer::new(move || {
    App::new()
        .app_data(registry.clone())
})
.bind(("127.0.0.1", 8080))?
.run()
.await

96 |     HttpServer::new(move || {
   |     ^^^^^^^^^^^^^^^ `dyn SendEncodeMetric` cannot be shared between threads safely

[mxinden]

But Arc can't be used with actix-web(or I do something wrong) - compiler says that:

On vacation right now, though #57 (comment) might help in the meantime.