ideogram-observability

Set up comprehensive observability for Ideogram integrations with metrics, traces, and alerts. Use when implementing monitoring for Ideogram operations, setting up dashboards, or configuring alerting for Ideogram integration health. Trigger with phrases like "ideogram monitoring", "ideogram metrics", "ideogram observability", "monitor ideogram", "ideogram alerts", "ideogram tracing".

Install with Tessl CLI

npx tessl i github:jeremylongshore/claude-code-plugins-plus-skills --skill ideogram-observability

What are skills?

1.36x

Quality

77%

Does it follow best practices?

Impact

100%

1.36x

Average score across 3 eval scenarios

Optimize this skill with Tessl

npx tessl skill review --optimize ./plugins/saas-packs/ideogram-pack/skills/ideogram-observability/SKILL.md

SKILL.md

Review

Evals

Ideogram Observability

Overview

Set up comprehensive observability for Ideogram integrations.

Prerequisites

Prometheus or compatible metrics backend
OpenTelemetry SDK installed
Grafana or similar dashboarding tool
AlertManager configured

Metrics Collection

Key Metrics

Metric	Type	Description
`ideogram_requests_total`	Counter	Total API requests
`ideogram_request_duration_seconds`	Histogram	Request latency
`ideogram_errors_total`	Counter	Error count by type
`ideogram_rate_limit_remaining`	Gauge	Rate limit headroom

Prometheus Metrics

import { Registry, Counter, Histogram, Gauge } from 'prom-client';

const registry = new Registry();

const requestCounter = new Counter({
  name: 'ideogram_requests_total',
  help: 'Total Ideogram API requests',
  labelNames: ['method', 'status'],
  registers: [registry],
});

const requestDuration = new Histogram({
  name: 'ideogram_request_duration_seconds',
  help: 'Ideogram request duration',
  labelNames: ['method'],
  buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5],
  registers: [registry],
});

const errorCounter = new Counter({
  name: 'ideogram_errors_total',
  help: 'Ideogram errors by type',
  labelNames: ['error_type'],
  registers: [registry],
});

Instrumented Client

async function instrumentedRequest<T>(
  method: string,
  operation: () => Promise<T>
): Promise<T> {
  const timer = requestDuration.startTimer({ method });

  try {
    const result = await operation();
    requestCounter.inc({ method, status: 'success' });
    return result;
  } catch (error: any) {
    requestCounter.inc({ method, status: 'error' });
    errorCounter.inc({ error_type: error.code || 'unknown' });
    throw error;
  } finally {
    timer();
  }
}

Distributed Tracing

OpenTelemetry Setup

import { trace, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.getTracer('ideogram-client');

async function tracedIdeogramCall<T>(
  operationName: string,
  operation: () => Promise<T>
): Promise<T> {
  return tracer.startActiveSpan(`ideogram.${operationName}`, async (span) => {
    try {
      const result = await operation();
      span.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (error: any) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      span.recordException(error);
      throw error;
    } finally {
      span.end();
    }
  });
}

Logging Strategy

Structured Logging

import pino from 'pino';

const logger = pino({
  name: 'ideogram',
  level: process.env.LOG_LEVEL || 'info',
});

function logIdeogramOperation(
  operation: string,
  data: Record<string, any>,
  duration: number
) {
  logger.info({
    service: 'ideogram',
    operation,
    duration_ms: duration,
    ...data,
  });
}

Alert Configuration

Prometheus AlertManager Rules

# ideogram_alerts.yaml
groups:
  - name: ideogram_alerts
    rules:
      - alert: IdeogramHighErrorRate
        expr: |
          rate(ideogram_errors_total[5m]) /
          rate(ideogram_requests_total[5m]) > 0.05
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Ideogram error rate > 5%"

      - alert: IdeogramHighLatency
        expr: |
          histogram_quantile(0.95,
            rate(ideogram_request_duration_seconds_bucket[5m])
          ) > 2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Ideogram P95 latency > 2s"

      - alert: IdeogramDown
        expr: up{job="ideogram"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Ideogram integration is down"

Dashboard

Grafana Panel Queries

{
  "panels": [
    {
      "title": "Ideogram Request Rate",
      "targets": [{
        "expr": "rate(ideogram_requests_total[5m])"
      }]
    },
    {
      "title": "Ideogram Latency P50/P95/P99",
      "targets": [{
        "expr": "histogram_quantile(0.5, rate(ideogram_request_duration_seconds_bucket[5m]))"
      }]
    }
  ]
}

Instructions

Step 1: Set Up Metrics Collection

Implement Prometheus counters, histograms, and gauges for key operations.

Step 2: Add Distributed Tracing

Integrate OpenTelemetry for end-to-end request tracing.

Step 3: Configure Structured Logging

Set up JSON logging with consistent field names.

Step 4: Create Alert Rules

Define Prometheus alerting rules for error rates and latency.

Output

Metrics collection enabled
Distributed tracing configured
Structured logging implemented
Alert rules deployed

Error Handling

Issue	Cause	Solution
Missing metrics	No instrumentation	Wrap client calls
Trace gaps	Missing propagation	Check context headers
Alert storms	Wrong thresholds	Tune alert rules
High cardinality	Too many labels	Reduce label values

Examples

Quick Metrics Endpoint

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', registry.contentType);
  res.send(await registry.metrics());
});

Resources

Next Steps

For incident response, see ideogram-incident-runbook.

Repository: jeremylongshore/claude-code-plugins-plus-skills
Commit: 213e2bd
Last updated: 2 days ago
Created: 2 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.