asterisk_recording_exporter

#!/usr/bin/env python3.4
import inspect
import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))

import threading
from http.server import HTTPServer
import socket
import time

from prometheus.collectors import Gauge
from prometheus.registry import Registry
from prometheus.exporter import PrometheusMetricHandler

PORT_NUMBER = 9255

def gather_data(registry):
    """Gathers the metrics"""
    host = socket.gethostname()

    asterisk_total_active_channels_metric = Gauge("asterisk_active_channels", "Total current acitve channels",
                       {'host': host})
    asterisk_total_active_calls_metric = Gauge("asterisk_active_calls", "Total current acitve calls",
                       {'host': host})
    asterisk_total_calls_processed_metric = Gauge("asterisk_calls_processed", "Total current calls processed",
                       {'host': host})
    asterisk_total_sip_peers_metric = Gauge("asterisk_sip_peers", "Total sip peers",
                       {'host': host})
    asterisk_total_sip_peers_online_metric = Gauge("asterisk_sip_peers_online", "Total sip peers online",
                       {'host': host})
    asterisk_total_sip_peers_offline_metric = Gauge("asterisk_sip_peers_offline", "Total sip peers offline",
                       {'host': host})
    asterisk_total_core_uptime_metric = Gauge("asterisk_core_uptime", "Total core uptime",
                       {'host': host})
    siprec_total_recording_metric = Gauge("siprec_total_recording", "Total siprec file",
                       {'host': host})                           


    registry.register(asterisk_total_active_calls_metric)
    registry.register(asterisk_total_active_channels_metric)
    registry.register(asterisk_total_calls_processed_metric)
    registry.register(asterisk_total_sip_peers_metric)
    registry.register(asterisk_total_sip_peers_online_metric)
    registry.register(asterisk_total_sip_peers_offline_metric)
    registry.register(asterisk_total_core_uptime_metric)
    registry.register(siprec_total_recording_metric)


    while True:
        time.sleep(1)

        command_active_channels = "asterisk -rx 'core show channels' | grep 'active channels' | awk '{print $1}'"
        command_active_calls = "asterisk -rx 'core show calls' | grep 'active call' | awk '{print $1}'"
        command_calls_processed = "asterisk -rx 'core show channels' | grep 'calls processed' | awk '{print $1}'"
        command_sip_peers = "asterisk -rx 'sip show peers' | grep 'sip peers' | awk '{print $1}'"
        command_sip_peers_online = "asterisk -rx 'sip show peers' | grep 'sip peers' | awk '{print $5}'"
        command_sip_peers_offline = "asterisk -rx 'sip show peers' | grep 'sip peers' | awk '{print $7}'"
        command_core_uptime = "asterisk -rx 'core show uptime seconds' | grep 'System uptime' | awk '{print $3}'"
        command_siprec_total_recording = "ls /winshare/siprec/ | wc -l"

        active_channels = os.popen(command_active_channels).read()
        asterisk_total_active_channels_metric.set({'type': "active channels", }, active_channels)

        active_calls = os.popen(command_active_calls).read()
        asterisk_total_active_calls_metric.set({'type': "active calls", }, active_calls)

        calls_processed = os.popen(command_calls_processed).read()
        asterisk_total_calls_processed_metric.set({'type': "calls processed", }, calls_processed)
        
        sip_peers = os.popen(command_sip_peers).read()
        asterisk_total_sip_peers_metric.set({'type': "sip peers", }, sip_peers)
        
        sip_peers_online = os.popen(command_sip_peers_online).read()
        asterisk_total_sip_peers_online_metric.set({'type': "sip peers online", }, sip_peers_online)

        sip_peers_offline = os.popen(command_sip_peers_offline).read()
        asterisk_total_sip_peers_offline_metric.set({'type': "sip peers offline", }, sip_peers_offline)
        
        core_uptime = os.popen(command_core_uptime).read()
        asterisk_total_core_uptime_metric.set({'type': "core uptime", }, core_uptime)
                
        siprec_total_recording = os.popen(command_siprec_total_recording).read()
        siprec_total_recording_metric.set({'type': "total siprec file", }, siprec_total_recording)        
        
if __name__ == "__main__":

    registry = Registry()

    thread = threading.Thread(target=gather_data, args=(registry, ))
    thread.start()
    try:
        def handler(*args, **kwargs):
            PrometheusMetricHandler(registry, *args, **kwargs)

        server = HTTPServer(('', PORT_NUMBER), handler)
        server.serve_forever()

    except KeyboardInterrupt:
        server.socket.close()
        thread.join()