Building a Gonzo Prometheus Exporter in Docker¶

# exporter.py
from prometheus_client import start_http_server, Gauge, Counter, Histogram, Summary
import time
import random
import os
import math
from datetime import datetime

# Weird metrics that actually work
coffee_temp = Gauge("coffee_mug_temperature_celsius", "Temperature of your coffee mug")
existential_crisis = Gauge("existential_crisis_intensity", "Scale of existential dread", ["developer"])
dice_entropy = Counter("entropy_of_dice_rolls_total", "Entropy generated by dice rolls")
goat_heartbeat = Gauge("goat_heartbeat_rate", "Heartbeat rate of the office goat", ["goat_name"])
beer_consumption = Counter("beer_consumption_total", "Total beers consumed", ["brand", "location"])
universe_entropy = Gauge("entropy_in_the_universe", "Entropy level of the universe")
midi_chaos = Counter("midi_chaos_events_total", "MIDI controller chaos events", ["controller", "pad"])
existential_questions = Counter("existential_questions_asked_total", "Deep questions about existence")
coffee_spills = Counter("coffee_spills_total", "Coffee spills in the office", ["severity"])
code_quality = Gauge("code_quality_score", "Subjective code quality score", ["language", "project"])
random_thoughts = Counter("random_thoughts_per_minute", "Random thoughts generated per minute")
chaos_level = Gauge("chaos_level", "Current level of chaos in the system")
developer_sanity = Gauge("developer_sanity_level", "Developer sanity meter", ["developer", "project"])

# Histogram for response times of existential queries
existential_query_duration = Histogram("existential_query_duration_seconds", "Time spent pondering existence")

# Summary for coffee consumption patterns
coffee_consumption_summary = Summary("coffee_consumption_seconds", "Time spent drinking coffee")

def generate_entropy():
    """Generate entropy from system randomness"""
    try:
        with open('/dev/urandom', 'rb') as f:
            entropy_bytes = f.read(4)
            return int.from_bytes(entropy_bytes, 'big') / (2**32)
    except:
        return random.random()

def update_metrics():
    """Update all the weird metrics"""
    while True:
        # Coffee temperature (realistic range)
        coffee_temp.set(random.uniform(10.0, 95.0))

        # Existential crisis intensity
        existential_crisis.labels(developer="you").set(random.uniform(0, 100))

        # Dice entropy (simulate rolling dice)
        dice_rolls = [random.randint(1, 6) for _ in range(10)]
        entropy = -sum(p * math.log2(p) for p in [dice_rolls.count(i)/10 for i in range(1, 7)] if p > 0)
        dice_entropy.inc(entropy)

        # Goat heartbeat (office pet)
        goat_heartbeat.labels(goat_name="Gerald").set(random.uniform(60, 120))

        # Beer consumption (simulate drinking)
        if random.random() < 0.1:  # 10% chance of drinking
            brands = ["IPA", "Stout", "Lager", "Porter", "Wheat"]
            locations = ["office", "home", "bar", "conference"]
            beer_consumption.labels(
                brand=random.choice(brands),
                location=random.choice(locations)
            ).inc()

        # Universe entropy (from system randomness)
        universe_entropy.set(generate_entropy() * 100)

        # MIDI chaos (simulate button presses)
        if random.random() < 0.05:  # 5% chance of MIDI event
            controllers = ["Akai", "Novation", "Arturia", "Native Instruments"]
            pads = ["kick", "snare", "hihat", "crash", "ride"]
            midi_chaos.labels(
                controller=random.choice(controllers),
                pad=random.choice(pads)
            ).inc()

        # Existential questions
        if random.random() < 0.02:  # 2% chance of deep thought
            existential_questions.inc()

        # Coffee spills
        if random.random() < 0.01:  # 1% chance of spill
            severities = ["minor", "major", "catastrophic"]
            coffee_spills.labels(severity=random.choice(severities)).inc()

        # Code quality (subjective)
        languages = ["Python", "JavaScript", "Rust", "Go", "Java"]
        projects = ["main", "experimental", "legacy", "refactor"]
        code_quality.labels(
            language=random.choice(languages),
            project=random.choice(projects)
        ).set(random.uniform(0, 10))

        # Random thoughts
        random_thoughts.inc(random.randint(0, 5))

        # Chaos level (system-wide)
        chaos_level.set(random.uniform(0, 100))

        # Developer sanity
        developers = ["Alice", "Bob", "Charlie", "Diana"]
        projects = ["frontend", "backend", "devops", "data"]
        developer_sanity.labels(
            developer=random.choice(developers),
            project=random.choice(projects)
        ).set(random.uniform(0, 100))

        # Simulate existential query duration
        with existential_query_duration.time():
            time.sleep(random.uniform(0.1, 2.0))

        # Coffee consumption summary
        with coffee_consumption_summary.time():
            time.sleep(random.uniform(0.5, 3.0))

        time.sleep(2)  # Update every 2 seconds

if __name__ == "__main__":
    print("Starting Gonzo Prometheus Exporter...")
    print("Metrics will be available at http://localhost:8000/metrics")
    print("Press Ctrl+C to stop")

    start_http_server(8000)
    update_metrics()

# advanced_exporter.py
from prometheus_client import start_http_server, Gauge, Counter, Histogram, Summary, Info
import time
import random
import json
import requests
from datetime import datetime, timedelta

# System info metric
system_info = Info("gonzo_system_info", "Information about the gonzo system")
system_info.info({
    "version": "1.0.0",
    "chaos_level": "maximum",
    "developer": "you",
    "philosophy": "existential"
})

# Weather-based metrics (if API available)
weather_mood = Gauge("weather_mood_index", "Mood based on weather conditions", ["city"])
moon_phase = Gauge("moon_phase_influence", "Influence of moon phase on productivity")

# Social media chaos
twitter_chaos = Counter("twitter_chaos_events_total", "Chaos events from social media", ["platform"])
meme_virality = Gauge("meme_virality_score", "Viral potential of current memes", ["meme_type"])

# Time-based metrics
time_of_day = Gauge("time_of_day_hour", "Current hour of the day")
day_of_week = Gauge("day_of_week", "Current day of the week (0=Monday)")
productivity_cycle = Gauge("productivity_cycle", "Natural productivity cycle", ["developer"])

def get_weather_mood(city="San Francisco"):
    """Get weather-based mood (mock implementation)"""
    try:
        # In real implementation, call weather API
        weather_conditions = ["sunny", "cloudy", "rainy", "stormy", "foggy"]
        condition = random.choice(weather_conditions)
        mood_scores = {"sunny": 8, "cloudy": 5, "rainy": 3, "stormy": 2, "foggy": 4}
        return mood_scores.get(condition, 5)
    except:
        return random.uniform(0, 10)

def get_moon_phase():
    """Calculate moon phase influence"""
    now = datetime.now()
    # Simple moon phase calculation
    days_since_new_moon = (now - datetime(2024, 1, 1)).days % 29.5
    phase = (days_since_new_moon / 29.5) * 100
    return phase

def update_advanced_metrics():
    """Update advanced weird metrics"""
    while True:
        # Weather mood
        cities = ["San Francisco", "New York", "London", "Tokyo", "Sydney"]
        for city in cities:
            weather_mood.labels(city=city).set(get_weather_mood(city))

        # Moon phase influence
        moon_phase.set(get_moon_phase())

        # Social media chaos
        if random.random() < 0.03:  # 3% chance of social media chaos
            platforms = ["Twitter", "LinkedIn", "Reddit", "HackerNews"]
            twitter_chaos.labels(platform=random.choice(platforms)).inc()

        # Meme virality
        meme_types = ["cat", "dog", "programming", "existential", "coffee"]
        for meme_type in meme_types:
            meme_virality.labels(meme_type=meme_type).set(random.uniform(0, 100))

        # Time-based metrics
        now = datetime.now()
        time_of_day.set(now.hour)
        day_of_week.set(now.weekday())

        # Productivity cycle (simulate natural rhythms)
        developers = ["Alice", "Bob", "Charlie", "Diana"]
        for dev in developers:
            # Simulate different productivity patterns
            base_cycle = math.sin((now.hour - 9) * math.pi / 12) * 50 + 50
            random_factor = random.uniform(-20, 20)
            productivity_cycle.labels(developer=dev).set(max(0, base_cycle + random_factor))

        time.sleep(5)  # Update every 5 seconds

if __name__ == "__main__":
    print("Starting Advanced Gonzo Prometheus Exporter...")
    print("Advanced metrics will be available at http://localhost:8000/metrics")

    start_http_server(8000)
    update_advanced_metrics()

# kafka_exporter.py
from prometheus_client import start_http_server, Counter, Gauge
import kafka
import json
import time
import random

# Kafka-backed metrics
beer_consumption_rate = Counter("beer_consumption_rate_total", "Beer consumption rate", ["brand", "location"])
party_vibes = Gauge("party_vibes_level", "Current party vibes level", ["venue"])
dance_moves = Counter("dance_moves_total", "Dance moves performed", ["style", "intensity"])

def consume_kafka_events():
    """Consume events from Kafka and update metrics"""
    consumer = kafka.KafkaConsumer(
        'beer-events',
        'party-events',
        'dance-events',
        bootstrap_servers=['kafka:9092'],
        value_deserializer=lambda m: json.loads(m.decode('utf-8'))
    )

    for message in consumer:
        if message.topic == 'beer-events':
            data = message.value
            beer_consumption_rate.labels(
                brand=data.get('brand', 'unknown'),
                location=data.get('location', 'unknown')
            ).inc()

        elif message.topic == 'party-events':
            data = message.value
            party_vibes.labels(venue=data.get('venue', 'unknown')).set(
                data.get('vibes_level', 0)
            )

        elif message.topic == 'dance-events':
            data = message.value
            dance_moves.labels(
                style=data.get('style', 'unknown'),
                intensity=data.get('intensity', 'low')
            ).inc()

if __name__ == "__main__":
    start_http_server(8000)
    consume_kafka_events()

# entropy_exporter.py
from prometheus_client import start_http_server, Gauge
import os
import time
import hashlib

# Entropy metrics
system_entropy = Gauge("system_entropy_level", "System entropy level")
universe_entropy = Gauge("universe_entropy_level", "Universe entropy level")
randomness_quality = Gauge("randomness_quality_score", "Quality of system randomness")

def measure_entropy():
    """Measure entropy from system randomness"""
    try:
        with open('/dev/urandom', 'rb') as f:
            entropy_bytes = f.read(1024)
            entropy_hash = hashlib.sha256(entropy_bytes).hexdigest()
            # Convert hash to entropy score
            entropy_score = sum(int(c, 16) for c in entropy_hash) / (len(entropy_hash) * 15)
            return entropy_score
    except:
        return 0.5

def update_entropy_metrics():
    """Update entropy metrics"""
    while True:
        # System entropy
        system_entropy.set(measure_entropy())

        # Universe entropy (simulated)
        universe_entropy.set(random.uniform(0, 100))

        # Randomness quality
        randomness_quality.set(random.uniform(0, 10))

        time.sleep(1)

if __name__ == "__main__":
    start_http_server(8000)
    update_entropy_metrics()

# midi_exporter.py
from prometheus_client import start_http_server, Counter, Gauge
import mido
import time
import threading

# MIDI metrics
midi_events = Counter("midi_events_total", "MIDI events received", ["controller", "channel", "note"])
midi_velocity = Gauge("midi_velocity", "MIDI velocity", ["controller", "channel"])
midi_pressure = Gauge("midi_pressure", "MIDI pressure", ["controller", "channel"])
chaos_level = Gauge("midi_chaos_level", "MIDI chaos level")

def handle_midi_message(msg):
    """Handle MIDI messages and update metrics"""
    if msg.type == 'note_on':
        midi_events.labels(
            controller="Akai",
            channel=msg.channel,
            note=msg.note
        ).inc()

        midi_velocity.labels(
            controller="Akai",
            channel=msg.channel
        ).set(msg.velocity)

        # Update chaos level based on velocity
        chaos_level.set(chaos_level._value._value + msg.velocity * 0.1)

def midi_listener():
    """Listen for MIDI messages"""
    try:
        with mido.open_input() as port:
            for msg in port:
                handle_midi_message(msg)
    except:
        # Simulate MIDI events if no controller available
        while True:
            time.sleep(random.uniform(0.1, 2.0))
            # Simulate MIDI event
            midi_events.labels(
                controller="Simulated",
                channel=random.randint(0, 15),
                note=random.randint(60, 72)
            ).inc()

if __name__ == "__main__":
    start_http_server(8000)

    # Start MIDI listener in separate thread
    midi_thread = threading.Thread(target=midi_listener)
    midi_thread.daemon = True
    midi_thread.start()

    # Keep main thread alive
    while True:
        time.sleep(1)

# Real-world metric examples
real_world_metrics = {
    "business_metrics": [
        "user_engagement_score",
        "content_virality_index",
        "social_sentiment_level"
    ],
    "creative_metrics": [
        "artistic_inspiration_level",
        "creative_block_duration",
        "artistic_flow_state"
    ],
    "social_metrics": [
        "team_collaboration_quality",
        "meeting_effectiveness_score",
        "communication_chaos_level"
    ]
}

# Essential gonzo exporter operations
# 1. Define weird metrics
coffee_temp = Gauge("coffee_mug_temperature_celsius", "Coffee temperature")
existential_crisis = Gauge("existential_crisis_intensity", "Crisis level", ["developer"])

# 2. Update metrics
coffee_temp.set(random.uniform(10.0, 95.0))
existential_crisis.labels(developer="you").set(random.uniform(0, 100))

# 3. Start HTTP server
start_http_server(8000)

# 4. Keep updating
while True:
    update_metrics()
    time.sleep(2)