Table of Contents

Architecture overview

Reignite is easiest to understand as three cooperating planes:

  1. Customer runtime. An in-process profiler agent runs beside the customer application. It watches metrics, applies the thresholds the customer configured, and captures a trace or memory dump when a threshold is breached.
  2. Control plane. The API and website own the account, the application and profiler configuration, the trace-file lifecycle, artifact metadata and the analyst workflow. Binary artifacts live in Azure Blob Storage; metadata lives in Azure SQL Server.
  3. Analysis and remediation. A Reignite analyst claims a trace, downloads the artifact, records a root cause, and submits a fix as a pull request. The next profiling session verifies the regression.
flowchart TB
  subgraph Runtime["Customer runtime"]
    App["Customer application"] --> Agent["Profiler agent"]
  end
  subgraph Control["Control plane"]
    Web["Website"]
    API["Reignite API"]
    SQL[(Azure SQL Server)]
    Blob[(Azure Blob Storage)]
  end
  subgraph Remediation["Analysis and remediation"]
    Analyst["Reignite analyst"] --> Refactor["PerformanceRefactorer"]
    Refactor --> PullRequest["Pull request"]
  end
  Agent -->|"metrics and configuration"| API
  Agent -->|"trace and dump artifacts"| Blob
  Analyst -->|"claims traces"| Web
  Web --> API
  API --> SQL
  API --> Blob
  PullRequest -->|"customer deploys"| App

The generated views

The pages below are generated from architecture/model.yaml. Read them in this order:

View What it answers
System context Who uses Reignite, and which external systems does it depend on?
Container map Which services, agents, tools and data stores make up the platform?
External dependencies Which third-party systems are load-bearing, and why?
End-to-end flows How do the containers cooperate for a profiling session, a diagnosis or a deployment?
Repositories Where does each service live?
Environments Which URLs belong to development, integration, preproduction and production?

Design decisions a reader should know

  • The agent is in-process and threshold-driven. It does not continuously stream a full trace. It watches EventCounters and runtime metrics, and only pays the capture cost when a configured threshold is breached.
  • Artifacts and metadata are split. Large binaries go to Blob Storage; small, queryable records go to SQL. The API issues short-lived SAS URLs rather than handing out storage keys.
  • The trace file is the unit of work. Its lifecycle is explicit (Ready → Assigned → Downloaded → Started → Analyzed → Fixed → PRSubmitted → Deployed → Resolved → Closed), so an analyst can hand work to another analyst without losing state.
  • The diagnostics bots are read-only over the control plane. The diagnostic bot can read status and start an asynchronous diagnosis; it never issues a destructive command. The Teams bot is a separate multi-tenant service with its own SQL schema.
  • This site stops at the container boundary. For class-level detail, follow the repository links in the repository map.

Keeping the model current

When a system, container, relationship, repository or environment changes, update architecture/model.yaml and regenerate:

dotnet run --project tools/Reignite.Docs.Generator -- `
  --model architecture/model.yaml --docs docs

The generator validates the model first: duplicate ids, unknown relationship endpoints, unknown repositories and broken flow participants all fail the build instead of producing a diagram that silently omits an edge. --check verifies the committed pages are current.