https://github.com/ifonso/spd-logger
Primeiro projeto prático para a disciplina de sistemas paralelos e distribuídos
https://github.com/ifonso/spd-logger
concurrent-programming cpp
Last synced: 10 months ago
JSON representation
Primeiro projeto prático para a disciplina de sistemas paralelos e distribuídos
- Host: GitHub
- URL: https://github.com/ifonso/spd-logger
- Owner: ifonso
- Created: 2025-08-29T00:59:04.000Z (10 months ago)
- Default Branch: main
- Last Pushed: 2025-09-05T03:01:05.000Z (10 months ago)
- Last Synced: 2025-09-05T05:20:36.743Z (10 months ago)
- Topics: concurrent-programming, cpp
- Language: C++
- Homepage:
- Size: 19.5 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Logger de Aplicações (Produtor x Consumidor)
> O objetivo deste projeto é fornecer um exemplo do padrão produtor x consumidor usando multithreading em C++ para a disciplina de Sistemas Paralelos e Distribuídos.
Em uma aplicação, é comum nos depararmos com um cenário em que diferentes partes do sistema geram logs de execução com diferentes níveis de importância, como erros, avisos ou eventos. Normalmente, é essencial persistir esses dados em um sistema externo ou localmente em arquivos temporários, a fim de investigar possíveis problemas na aplicação.
Para esse cenário, teremos produtores de logs, simulando diferentes partes do sistema, e consumidores, que observam os logs e os persistem localmente em um arquivo temporário.
- Produtores: módulos independentes da aplicação que geram mensagens de log.
- Cada log segue um formato estruturado em **JSON**.
- Existem três tipos de log: **INFO**, **WARNING** e **ERROR**.
- Consumidor: responsável por ler os logs da fila (buffer) e gravá-los no arquivo central.
- Apenas um consumidor pode acessar o arquivo por vez, para garantir consistência dos dados.
**Exemplo de log**
```json
{
"timestamp": "2025-08-26T16:32:01Z",
"level": "ERROR",
"producer_id": 3,
"message": "Falha ao acessar banco de dados",
"thread": "Thread-Produtor-3"
}
```
### Arquitetura Simplificada
```mermaid
classDiagram
class Producer {
+start()
+stop()
~logging_routine()
}
class MessageBuffer {
+push(message)
+pop(message)
+shutdown()
}
class Consumer {
+start()
+stop()
~writing_routine()
}
class FileWriter {
+append(json_line)
}
class Logger {
+log(message, level, id)
}
%% Relacionamentos centralizados no MessageBuffer
Producer --> MessageBuffer : "escreve mensagens em"
Consumer --> MessageBuffer : "consume mensagens de"
Consumer --> FileWriter : "salva logs no arquivo"
Producer --> Logger : "usa para formatar"
%% Notas explicativas
note for Producer "Gera logs automaticamente"
note for MessageBuffer "Instância única - buffer central thread-safe"
note for Consumer "Consome mensagens do buffer"
note for FileWriter "Escrita thread-safe em arquivo JSON"
```
### Funcionamento
1. Sempre que um produtor gera uma mensagem de log, ela é colocada em um buffer compartilhado (fila).
2. O consumidor (ou consumidores) monitora esse buffer e, assim que um log está disponível, o remove da fila e escreve no arquivo de log.
3. Caso haja múltiplos consumidores, apenas um pode escrever no arquivo por vez. Enquanto um consumidor escreve, os demais aguardam.
4. Assim que o consumidor libera o arquivo, o próximo log da fila pode ser processado.
5. Uma vez que um log é consumido e gravado, ele é removido do buffer.
### Restrições
- O buffer possui capacidade limitada (exemplo: apenas 1 log por vez).
- Se o buffer estiver cheio, os produtores devem aguardar até que haja espaço para inserir novos logs.
- Se o buffer estiver vazio, os consumidores aguardam até que um novo log seja produzido.
- Enquanto um produtor escreve no buffer, outro deve esperar (exclusão mútua).
## Compilação
Este projeto utiliza CMake como sistema de build.
### Linux
Crie a pasta de build:
```bash
mkdir build && cd build
```
Gere os arquivos de build com o CMake:
```bash
cmake ..
```
Compile o projeto:
```bash
make
```
### Windows
Crie a pasta de build e entre nela:
```powershell
mkdir build
cd build
```
Gere os arquivos de build com o CMake (assumimos que você esteja usando MinGW):
```powershell
cmake .. -G "MinGW Makefiles"
```
Compile o projeto:
```powershell
mingw32-make
```