observability/tp2.md

# TP 2 Supervision d'un programme en C

Dans Visual Studio Code, assurez vous d'avoir l'extension suivante installée :
- [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)

Démarrer Docker en lançant Docker Desktop

Créer un réseau qui permettra à vos machines de communiquer entre elles.

```shell
docker network create tp_net
```

Cloner le dépot contenant les [sources](https://sources.neotech.fr/medina474/c_pompes) C programme sur les pompes

```shell
git clone https://sources.neotech.fr/Universite/c_pompes
```

```shell
cd c_pompes
```

run task CMake configure

tache config

Dans Visual Studio Code, chercher la commande Open Folder in Dev Container.... (Menu View - Command Palette ...)

L'extension va créer un conteneur Docker configuré avec les extensions nécessaires au dévelopement de l'application


### Ajouter un conteneur pour Prometheus

Créer un fichier de configuration prometheus.yml

```json
global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 1m
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'apps_dynamiques'
    file_sd_configs:
      - files:
        - /etc/prometheus/targets/*.yml

  - job_name: docker
    docker_sd_configs:
      - host: unix:///var/run/docker.sock
        refresh_interval: 15s
        filters:
          - name: label
            values: ['prometheus=true']
    relabel_configs:
      - source_labels: ['__meta_docker_container_name']
        regex: '/(.*)'
        target_label: 'container'
```

Créer un dossier prometheus

```shell
docker run --detach --name prometheus ^
  --network tp_net ^
  -p "9090:9090" ^
  -v prometheus:/prometheus ^
  -v ./prometheus.yml:/etc/prometheus/prometheus.yml ^
  -v ./prometheus:/etc/prometheus/targets ^
  -v /var/run/docker.sock:/var/run/docker.sock:ro ^
  -l "caddy=prometheus.localhost" ^
  -l "caddy.reverse_proxy={{upstreams 9090}}" ^
  -l "caddy.tls=internal" ^
  prom/prometheus:v3.8.0
```

Rendez vous à l'adresse http://localhost:9000

### Ajouter un conteneur pour Grafana

```shell
docker run --detach --name grafana ^
  --network tp_net ^
  -p "3000:3000" ^
  -e "GF_SECURITY_ADMIN_USER=admin" ^
  -e "GF_SECURITY_ADMIN_PASSWORD=geii2025" ^
  -e "GF_USERS_ALLOW_SIGN_UP=false" ^
  -e "GF_USERS_DEFAULT_THEME=system" ^
  --label "caddy=grafana.localhost" ^
  --label "caddy.reverse_proxy={{upstreams 3000}}" ^
  --label "caddy.tls=internal" ^
  grafana/grafana:12.1
```

```yml
- labels:
    job: "c"
  targets:
    - "pompes:8099"
```

### Ajouter un conteneur pour Mailpits

### Modifier le programme C


Inclure les bibliothèques

```Cpp
#include <prometheus/counter.h>
#include <prometheus/gauge.h>
#include <prometheus/registry.h>
#include <prometheus/exposer.h>
```

Déclarer les variables

```Cpp
using namespace prometheus;

std::shared_ptr<Registry> registry;
Gauge* debit_entree = nullptr;
Gauge* debit_sortie = nullptr;
```

Initialiser

```Cpp
static Exposer exposer{"0.0.0.0:8099"};

// Le registre central
registry = std::make_shared<Registry>();

exposer.RegisterCollectable(registry);

auto& gauge_family = BuildGauge()
      .Name("geii_debit")
      .Help("Débit en l/s")
      .Register(*registry);

debit_entree = &gauge_family.Add({{"numero", "entree"}});
debit_sortie = &gauge_family.Add({{"numero", "sortie"}});
```

Affecter les valeurs

```Cpp
debit_entree->Set(_digital[IN_FLOW_OUT].dvalue);
debit_sortie->Set(_digital[IN_FLOW_IN].dvalue);
```

### Construire un tableau de bord dans Grafana


### Ajouter d'autres métriques

Les gauges :

- IN_TANK_LEVEL
- IN_FLOW_1
- IN_FLOW_2
- IN_FLOW_3
- IN_FLOW_4


Comparer avec des compteurs

- Volume_p1
- Volume_p2
- Volume_p3
- Volume_p4

Ajouter un histogramme pour le volume dans le réservoir

- 2
- 5
- 6
- 7
- 8
- 9
- 9.5

```c
#include <prometheus/histogram.h>


Histogram::BucketBoundaries buckets = {
  2, 5, 6, 7, 8, 9, 9.5
};

auto& hist_family = BuildHistogram()
  .Name("volume")
  .Help("volume du reservoir en m3")
  .Register(*registry);

auto& request_volume = hist_family.Add({}, buckets);

request_volume.Observe(0.42);
```