fluxus-utils 0.1.2

Fluxus is a stream processing engine that provides a declarative and efficient way to process and analyze data streams.
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

# Fluxus Stream Processing Engine

[![Crates.io](https://img.shields.io/crates/v/fluxus-core.svg)](https://crates.io/crates/fluxus-core)
[![Documentation](https://docs.rs/fluxus-core/badge.svg)](https://docs.rs/fluxus-core)
[![License: Apache 2.0](https://img.shields.io/badge/License-Apache2.0-yellow.svg)](https://opensource.org/license/apache-2-0)
[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/lispking/fluxus/ci.yml?branch=main&style=for-the-badge" height="20">](https://github.com/lispking/fluxus/actions?query=branch%3Amain)


Fluxus is a lightweight stream processing engine written in Rust, designed for efficient real-time data processing and analysis.

![Fluxus Architecture](docs/architecture.png)

## Features

- High-performance stream processing
- Flexible windowing operations (Tumbling, Sliding, Session windows)
- Parallel processing support
- Rich set of stream operations (map, filter, aggregate)
- Type-safe API
- Easy to use and extend

## Project Structure

- `crates/fluxus` - Main crate containing the Fluxus engine and its dependencies
- `crates/fluxus-api` - Core API definitions and interfaces
- `crates/fluxus-core` - Core implementations and data structures
- `crates/fluxus-runtime` - Runtime engine and execution environment
- `crates/fluxus-sinks` - Sink implementations for different data sinks (e.g., Kafka, Console)
- `crates/fluxus-sources` - Source implementations for different data sources (e.g., Kafka, Console)
- `crates/fluxus-transforms` - Transformations for stream processing (e.g., map, filter, aggregate)
- `crates/fluxus-utils` - Utility functions and helpers
- `examples` - Example applications demonstrating usage

## Examples

The project includes several example applications that demonstrate different use cases:

### Word Count

Simple word frequency analysis in text streams using tumbling windows.

```bash
cargo run --example word-count
```

### Temperature Sensor Analysis

Processing and analyzing temperature sensor data with sliding windows.

```bash
cargo run --example temperature-sensor
```

### Click Stream Analysis

Analyzing user click streams with session windows.

```bash
cargo run --example click-stream
```

### Network Log Analysis

Processing network logs with sliding windows and aggregations.

```bash
cargo run --example network-log
```

### View Available Examples

To see all available examples and options:

```bash
cargo run --example
```

## Getting Started

1. Clone the repository:

```bash
git clone https://github.com/lispking/fluxus.git
cd fluxus
```

2. Build the project:

```bash
cargo build
```

3. Run the examples:

```bash
cargo run --example [example-name]
```

## Development

### Prerequisites

- Rust 1.75+ 
- Cargo 

### Building

```bash
cargo build
```

### Testing

```bash
cargo test
```

## License

This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.