async_logger 0.3.1

Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# async_logger

![Rust](https://github.com/stencillogic/async_logger/workflows/Rust/badge.svg)

Asynchronous logger allows writing arbitrary slices to a memory buffer, that then processed by a writer in it's own thread.
See [crate documentation](https://docs.rs/async_logger/) for more info.

## Intro

`AsyncLoggerNB` is implementation of asynchronous logger that allows writing arbitrary slices to a memory buffer, 
and then send the buffer to a writer. 

NB at the end of `AsyncLoggerNB` stands for non-blocking. Implementation allows adding messages to a buffer without locking
the buffer which prevents other threads from writing. `AsyncLoggerNB` uses pair of fixed size buffers; 
while one buffer is being written by the multiple threads, the second is being proccessed by the
single writer thread. Blocking appears when buffers change their roles.
Thus, this implementation is applicable in situation of small (compared to the size of buffer) writes
by multiple threads running on multiple cpu cores with high concurrency of writes.

`AsyncLoggerNB` can process serialized data (stream of bytes) or custom complex data structures, references to objects.

`AsyncLoggerNB` can accept any writer implementation of `Writer` trait. This package includes
`FileWriter` that writes data to a file. You can create your own implementation of the `Writer`
trait as well.

Implementation of [log](https://docs.rs/log) facade based on this asynchronous logger is available as separate crate
[async_logger_log](https://docs.rs/async_logger_log). Please refer to `async_logger_log` crate documentation for more info and examples.

## Examples

```
use async_logger::FileWriter;
use async_logger::AsyncLoggerNB;
use std::{thread, sync::Arc};

let writer = FileWriter::new("/tmp", 10*1024*1024).expect("Failed to create file writer");

let logger = Arc::new(AsyncLoggerNB::new(Box::new(writer), 8192)
    .expect("Failed to create new async logger"));

let write_line = "Hello, world!\n";

let logger_c = logger.clone();

let handle = thread::spawn(move || {

    logger_c.write_slice(write_line.as_bytes()).unwrap();
    logger_c.write_slice(write_line.as_bytes()).unwrap();
    logger_c.flush();

    logger_c.write_slice(write_line.as_bytes()).unwrap();

});

handle.join().expect("Failed on thread join");

match Arc::try_unwrap(logger) {
    Ok(logger) => logger.terminate(),
    Err(_) => panic!("Failed to terminate logger because it is still in use"),
};
```

## Notes

1. This crate was tested on Linux x86_64. Rust version 1.42.