Spekra brings infrastructure, application traces, logs, endpoint checks and incident response into one organization workspace—with dashboards, billing review, Docker configuration evidence and database schema comparisons. Start with the suites your team needs.
Choose the supported workflows your team needs. Six suites passed recorded controlled matrices; FinOps, SecOps and AI/schema retain documented gaps. Availability depends on enabled features and adapter scope.
Inspect PostgreSQL/MySQL query and connection observations, host resource measurements and selected Redis cache evidence.
Bring resource and database context together during an investigation.
Infrastructure and Redis Monitoring →
Follow supplied request spans in waterfalls, review observed service statistics and query supported OTLP JSON metrics.
Examine request timing and related database or log evidence.
Submit application logs, follow live updates, filter by source/level/time and search text or bounded regex.
Find relevant messages and follow supplied trace identifiers.
Run real public HTTP/HTTPS checks with timing, certificate observations, history and linked failure/recovery incidents.
Review endpoint behavior and certificate evidence from one worker location.
Coordinate incident timelines, on-call schedules, signed generic HTTPS paging, responder acknowledgement and opt-in escalation.
Keep response handoffs visible; run defined evidence and endpoint-verification workflows.
Import normalized billing JSON and inspect exact charges, credits, resource breakdowns and advisory spend findings.
Consolidate exported cost evidence without mixing currencies or estimates with billed charges.
Configure and save widgets and layouts using supported summaries from the suites enabled for your organization.
Keep recurring operational checks in a shared view.
Collect and import selected Docker configuration, inspect nine custom checks, and retain source evidence and audit history.
Make configuration review repeatable while identifying missing or stale observations.
Capture and compare read-only PostgreSQL/MySQL schema evidence. Suite 1 separately supports opt-in reviewed datasets and advisory shadow comparisons.
Review supported structural changes and evaluate measured learning data; production AI diagnosis and automatic DDL remain unavailable.
Review availability, deployment requirements and remaining limits →
Explore 23 independent tools for engineering teams, shared plans and everyday work.
For SaaS teams, platform engineers and agencies managing application operations: gather evidence, coordinate responders and make recurring reviews easier to follow.
These interactive examples are illustrative browser demonstrations. They are not live customer measurements or production certifications. See the current capabilities guide for supported workflows.
| Inbound API Route | Microservice | Target Database | Tables & Operations Touched | DB Latency Share | Action |
|---|---|---|---|---|---|
POST /api/v1/orders/checkout |
checkout-service |
PostgreSQL Order DB (Primary) | 🗄️ users SELECT 🗄️ orders INSERT 🗄️ inventory_reservations | 72.4% (351ms / 485ms) | Explain Plan |
GET /api/v1/users/profile |
auth-service |
PostgreSQL Auth Cluster | 🗄️ users SELECT 🗄️ sessions SELECT | 36.8% (14ms / 38ms) | Explain Plan |
POST /api/v1/payments/charge |
payment-service |
PostgreSQL Payments DB | 🗄️ payments INSERT 🗄️ orders UPDATE | 25.5% (42ms / 165ms) | Explain Plan |
POST /api/v1/orders/checkout represents 72.4% of database execution time on cluster pulse_production.SELECT * FROM users WHERE email = ? is executing a Sequential Scan over 45,000 rows because an index is missing on email.Plan coverage, send signed webhook pages, and follow the response from receiver acceptance to a signed-in human acknowledgement.
Create scheduled shifts, daily or weekly rotations, and temporary coverage overrides. Timezone-aware handovers preserve local times across daylight-saving changes. The calendar exposes gaps and overlaps.
Enable acknowledgement deadlines for primary, secondary, and tertiary responders. Scheduled steps survive restarts and prevent duplicate child pages. A page acknowledgement or incident resolution stops waiting escalation.
Opt into HMAC-SHA256 signatures that bind the request body, time, organization, channel, and delivery ID. Signing secrets are encrypted on the server. Prepare a key, install it at your receiver, then activate it.
Check receiver health and review rejected, uncertain, blocked, or exhausted pages. A signed-in operator can send an explicit follow-up with a reason and audit history. Repeated requests reuse the same attempt.
Available now: generic HTTPS webhook paging, scheduled coverage, opt-in escalation, receiver checks, operator re-paging, and encrypted signing-key rotation. Local TLS receiver and browser checks pass. Your receiver still needs signature verification and replay protection; live staging acceptance remains environment-specific. Authenticated generic receiver callbacks now support delivery receipts and mapped responder acknowledgements. Unmapped identities require review; native provider adapters remain planned. Production runbooks now capture incident evidence and recheck tenant-owned synthetic monitors, with dry-run validation, measured results, persisted history and duplicate-request protection. Infrastructure-changing remediation commands remain demo-only.
Configure signing and escalation through an organization administrator. Signing and automatic escalation are opt-in.
Supporting workflows connect the suites your organization enables.
Find selected targets, traces, logs, incidents, monitors, billing records and saved dashboards across enabled suites. Access is checked again when opening a result; search covers bounded recent records.
Explore search and organization access →Review permitted traces, logs, query aggregates, host samples and timeline events around an incident. Labels distinguish explicit identifier links from contextual matches.
Explore incident investigations →Agree the required suites and success measures, review setup milestones and collect feedback. Approved customers choose their password through a single-use invitation delivered by the operator.
Explore pilot onboarding and deployment →Build a feedback loop around measured PostgreSQL and MySQL telemetry. Your team confirms the evidence; models stay in shadow mode.
An organization administrator enables collection. Capture numeric connection usage, blocked sessions, and collector-host CPU. Incomplete measurements are skipped.
Label normal behavior or multiple concurrent faults. Group observations from the same incident and correct suggestions that disagree with the evidence.
Export reviewed records as a frozen, checksum-versioned dataset. Separate training runs evaluate later observations and a held-out site before reporting readiness.
Import a candidate for advisory comparisons. Uncertain predictions and readings near learned thresholds abstain. Collection can be disabled and stored learning data deleted.
Available now: the Suite 1 collection, review, export, training, and shadow workflow. Nine suite-specific synthetic baselines are experimental; real-data candidates need sufficient opted-in, reviewed telemetry and independent validation. Predictions never execute remediation. CPU describes the collector host, which may be separate from the database.
Organization administrator sign-in required. Use the Database model review link in your console’s suite menu.
No complex YAML configurations. No intrusive kernel modules.
Agree which workflows matter: infrastructure, application evidence, endpoint checks, incident response or imported cost/configuration review. Set up the required collectors, exporters or imports and verify permissions, network paths and redaction.
Check that your selected sources arrive with useful identity and timestamps. Exercise an instrumented request, endpoint failure/recovery, paging handoff or billing/configuration import according to your pilot goals.
Build a saved dashboard, use search to find the relevant records and investigate shared evidence. Measure the time your team spends on the selected operational task before and during the pilot.
Release hardening includes an HTTPS proxy profile, verified backup/restore tools, session revocation and bounded requests. Local checks do not certify public DNS, certificate renewal, sustained load or compliance. Public rollout requires operator verification.
Workspace search finds enabled suites and recent tenant-owned records. Results and feature filters follow your organization’s current entitlements, with access checked again when you open a result.
Choose an investigation, on-call handoff, endpoint check or billing/configuration review. Compare the effort before and during your pilot. Include setup, hosting and maintenance effort. There is no verified fixed saving or complete vendor-replacement guarantee.
Send OTLP JSON traces and metrics to your Spekra application. Use your organization’s API key and application URL; this marketing website is not a telemetry receiver.
Metric gauges, sums and explicit histograms are stored per organization and available in the APM metrics table or GET /api/v1/apm/metrics. Inspect partial-success responses for rejected points; exponential histograms and summaries are not supported.
# Connectivity tests; empty batches do not create trace spans.
export SPEKRA_URL="http://localhost:4000"
export PULSE_API_KEY="YOUR_TENANT_API_KEY"
curl --fail-with-body "$SPEKRA_URL/v1/traces" \
-H "Content-Type: application/json" \
-H "X-Pulse-Api-Key: $PULSE_API_KEY" \
--data '{"resourceSpans":[]}'
curl --fail-with-body "$SPEKRA_URL/v1/metrics" \
-H "Content-Type: application/json" \
-H "X-Pulse-Api-Key: $PULSE_API_KEY" \
--data '{"resourceMetrics":[]}'// Node.js 18+: send one OTLP JSON trace (not automatic instrumentation).
// Set SPEKRA_URL and PULSE_API_KEY before running this file.
const { randomBytes } = require('node:crypto');
const end = BigInt(Date.now()) * 1000000n;
const span = {
traceId: randomBytes(16).toString('hex'),
spanId: randomBytes(8).toString('hex'),
name: 'checkout', kind: 2,
startTimeUnixNano: String(end - 5000000n),
endTimeUnixNano: String(end)
};
async function send() {
if (!process.env.PULSE_API_KEY) throw new Error('Set PULSE_API_KEY');
const response = await fetch(
(process.env.SPEKRA_URL || 'http://localhost:4000') + '/v1/traces', {
method: 'POST',
headers: { 'Content-Type': 'application/json',
'X-Pulse-Api-Key': process.env.PULSE_API_KEY },
body: JSON.stringify({ resourceSpans: [{
resource: { attributes: [{ key: 'service.name',
value: { stringValue: 'checkout-service' } }] },
scopeSpans: [{ spans: [span] }]
}] })
});
if (!response.ok) throw new Error('Ingestion failed: ' + response.status);
console.log(await response.json());
}
send().catch(error => { console.error(error.message); process.exitCode = 1; });# Python standard library: send one OTLP JSON trace.
# For SDK instrumentation, route through the Collector example.
import json, os, secrets, time
from urllib.request import Request, urlopen
end = time.time_ns()
span = {
"traceId": secrets.token_hex(16), "spanId": secrets.token_hex(8),
"name": "checkout", "kind": 2,
"startTimeUnixNano": str(end - 5_000_000),
"endTimeUnixNano": str(end)
}
body = {"resourceSpans": [{
"resource": {"attributes": [{"key": "service.name",
"value": {"stringValue": "checkout-service"}}]},
"scopeSpans": [{"spans": [span]}]
}]}
request = Request(
os.environ.get("SPEKRA_URL", "http://localhost:4000") + "/v1/traces",
data=json.dumps(body).encode(), method="POST",
headers={"Content-Type": "application/json",
"X-Pulse-Api-Key": os.environ["PULSE_API_KEY"]})
with urlopen(request, timeout=10) as response:
print(response.read().decode())# Point your SDK's OTLP exporter at this Collector's port 4317 or 4318.
# Set SPEKRA_URL to your application origin (without /v1).
# Inside containers, use the application's reachable service URL.
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
processors:
batch: {}
exporters:
otlp_http/spekra:
endpoint: "${env:SPEKRA_URL}"
headers:
X-Pulse-Api-Key: "${env:PULSE_API_KEY}"
encoding: json
compression: none
service:
pipelines:
traces:
receivers: [otlp]
processors: [batch]
exporters: [otlp_http/spekra]
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlp_http/spekra]Use an API key from the organization that owns your telemetry. Invalid credentials are rejected.
The application accepts OTLP JSON. The Collector converts SDK OTLP traffic to JSON and sends uncompressed requests.
The Collector example uses the current otlp_http exporter name. Older Collector releases may use otlphttp; check your installed version’s documentation.
Collector configuration reference: OpenTelemetry OTLP HTTP exporter documentation.
Feature guides covering all nine suites, connected workflows, setup, customer value and current limits.
Review host CPU, memory, disk and network observations alongside Redis clients, memory, cache and slow-command evidence in Spekra.
Read the guide →Investigate application requests with span waterfalls, observed service statistics, SQL table associations and supported OpenTelemetry JSON metrics.
Read the guide →Centralize submitted application logs, filter by source, level and time, and follow trace identifiers into related request evidence.
Read the guide →Check public HTTP endpoints, inspect timing and certificate evidence, and track failures and recovery with Spekra synthetic monitoring.
Read the guide →Coordinate incident evidence, on-call coverage, generic HTTPS paging, responder acknowledgement, escalation and operational runbooks.
Read the guide →Import normalized billing exports, review charges and credits by currency, and inspect provider, service and resource costs in Spekra.
Read the guide →Save organization dashboards with configurable widgets and layouts for supported database, application, log, monitor, incident and billing summaries.
Read the guide →Review nine Docker configuration checks with source evidence, freshness and audit history. Understand the boundaries of Spekra SecOps.
Read the guide →Capture read-only PostgreSQL or MySQL catalog snapshots and review directional table, column and ordinary-index differences without executing DDL.
Read the guide →Find records across enabled suites, investigate shared evidence, manage organization roles and evaluate Spekra through reviewed pilot access.
Read the guide →Opt into measured database samples, label evidence, export versioned datasets and compare candidate models in advisory shadow mode.
Read the guide →Inspect PostgreSQL connections, running query shapes, locks and host context with Spekra. Explore collection, privacy limits and a guided pilot.
Read the guide →Understand Spekra's MySQL collection: status counters, process-list observations, connection capacity and locks, with clear setup and privacy limits.
Read the guide →An honest inventory of Spekra's supported workflows, partial suites, unavailable AI/remediation capabilities and the checks required for a guided pilot.
Read the guide →Local production-mode acceptance uses sample tenants, Docker databases and measured workloads. These results describe a finite test matrix, not production certification or a customer uptime guarantee.
Database monitoring, APM, logs, synthetics, incident workflows and dashboards were exercised with sample tenants. Coverage includes positive and negative cases within the recorded scenarios.
FinOps uses normalized billing imports; live provider coverage remains unverified. SecOps covers read-only Docker configuration evidence. Suite 9 supports read-only PostgreSQL and MySQL schema comparison; production AI diagnosis and DDL remediation are unavailable.
Availability also depends on your plan, configuration and supported source. Validate your own workload in a guided pilot before relying on an operational workflow.
Review supported capabilities and limits →Assess supported collection, source coverage, retention, integration effort and operating cost. We do not claim independently benchmarked superiority over other products.
Indicative published pricing. Confirm features, capacity, support and terms before purchasing; automatic checkout and subscription enforcement are not implemented.
Perfect for early-stage startups and small projects.
For growing engineering teams running production workloads.
For security-conscious enterprises with custom compliance needs.
Everything you need to know about Spekra deployment and security.
Spekra brings infrastructure and database monitoring, application traces, logs, endpoint checks, incident response, dashboards, imported billing review, Docker configuration evidence and schema comparison into an organization workspace. Teams search enabled suites, investigate evidence and coordinate operational work.
No. Six suites passed retained controlled real-data matrices. FinOps, SecOps and AI/schema coverage remain partial. Production AI diagnosis, automatic remediation and compliance certification are unavailable.
No. Measure collection impact with your workload. Database query normalization is limited to its collection path; logs and trace attributes require upstream redaction. Deployment, retention and encryption requirements need review.
A reachable application backend stores requests for operator review. Approved customers receive a manually delivered single-use invitation and choose their own password. Static hosting alone does not save requests or send email. Contact the operator if the backend is not available.
Connect directly with our engineering and architecture team for onboarding, custom deployments, or technical questions.
Instant answers from our technical team for sales inquiries, live demos, and private cloud rollout.
Send your infrastructure architecture questions, RFP documents, or proof-of-concept requirements.
Start with one staging application, an agreed investigation task and a measured pilot outcome. No fixed savings or MTTR improvement is guaranteed.