# Prometheus Mapper

A python mapper for select prometheus metrics.
We map a prometheus query to a user defined dict of output.

The main process is like:
User: query + params and output definition -> 
Mapper(get query output:MetricList) ->
list of dict rely on definition give.



# Installation

```shell
pip install git+https://github.com/pingcap-inc/prometheus_mapper.git
```

# Usage
Use `PrometheusMapper.list_map(list[MapRule])` to map query with params to user-defined output one by one:
```python
import asyncio
from datetime import datetime, timedelta

from aiohttp import ClientTimeout
from prometheus_mapper import PrometheusConnect, QueryParam, QueryRange, MapRule, PrometheusMapper


async def main():
    now = datetime.now()
    query_range = QueryRange(now - timedelta(0, 0, 0, 0, 30, 2), now - timedelta(0, 0, 0, 0, 10, 1), "30s")
    example_rules = [
        MapRule(
            query_param=QueryParam(
                arg=query_range,
                timeout="30s",
                query_template='kube_pod_info{namespace=~".*$instance"}',
                # ,pod=~"db-tikv-\\\d+|db-pd-\\\d+|db-tidb-\\\d+|db-tiflash-\\\d+"
                instance="1379661944629574082"
            ),
            selector_format={"node": "node"},
            do_unique=True,
        ),
        MapRule(
            query_param=QueryParam(
                arg=query_range,
                timeout="30s",
                query_template='rate(node_disk_reads_completed_total{instance="$node"}[2m])',
            ),
            selector_format={"ok": 'mean(values)', 'node': 'node', 'device': 'device'},
        ),
    ]
    async with PrometheusConnect(url="http://127.0.0.1:5555", timeout=ClientTimeout(total=10)) as conn:
        return await PrometheusMapper(conn).list_map(example_rules)


print(asyncio.run(main()))
```

Use `PrometheusMapper.map(MapRule)` to map query with params to user-defined output:
```python
import asyncio
from datetime import datetime, timedelta

from aiohttp import ClientTimeout
from prometheus_mapper import PrometheusConnect, QueryParam, QueryRange, MapRule, PrometheusMapper


async def main():
    now = datetime.now()
    query_range = QueryRange(now - timedelta(0, 0, 0, 0, 30, 2), now - timedelta(0, 0, 0, 0, 10, 1), "30s")
    example_rules = MapRule(
            query_param=QueryParam(
                arg=query_range,
                timeout="30s",
                query_template='kube_pod_info{namespace=~".*$instance"}',
                # ,pod=~"db-tikv-\\\d+|db-pd-\\\d+|db-tidb-\\\d+|db-tiflash-\\\d+"
                instance="1379661944629574082"
            ),
            selector_format={"namespace": "namespace"},
            do_unique=True,
        )
    async with PrometheusConnect(url="http://127.0.0.1:5555", timeout=ClientTimeout(total=10)) as conn:
        return await PrometheusMapper(conn).map(example_rules)


print(asyncio.run(main()))
```

Use `ClientMapper` to map a client result to list[dict[str, str]]:
```python
import asyncio
import time
from aiohttp import ClientTimeout
from prometheus_mapper import PrometheusConnect, QueryParam, ClientMapper


async def main():
    async with PrometheusConnect(url="http://127.0.0.1:5555", timeout=ClientTimeout(total=60)) as conn:
        mapper = ClientMapper(conn)
        param = QueryParam(arg=time.time(), timeout="5s", query_template='kube_node_info')
        results = await mapper.map(param)
        return results


print(asyncio.run(main()))
```

Use a async client to connecting from a Prometheus host.
Use QueryParam to query prometheus.
Client will parse extra function param of QueryParam like `instance="abc"` to `$instance`
```python
import asyncio
import time
from aiohttp import ClientTimeout
from prometheus_mapper import PrometheusConnect, QueryParam
from result import Result


async def main():
    async with PrometheusConnect(url="http://127.0.0.1:5555", timeout=ClientTimeout(total=10)) as conn:
        param = QueryParam(arg=time.time(), timeout="5s",
                           query_template='kube_node_info{instance="$instance"}',
                           instance="abc")
        output: Result = await param.query(conn)
        return output


print(asyncio.run(main()))
```