Architecture overview
Reignite is easiest to understand as three cooperating planes:
- 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.
- 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.
- 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.