Dynamic analysis in Guardian

Dynamic analysis observes an application while it runs, rather than reading it as written. Guardian ships a command group for it. It is not production-ready, and this page exists so that nobody has to discover that the hard way.

Status

ExperimentalNot production-ready. Do not build a release gate on it, and do not treat its output as coverage.

Available today: the command group is present and you can run --help against it on your installed build.
Not available: a documented check inventory, documented prerequisites, verified output, and any form of one-command operation.
Planned: a simplified workflow, documented requirements and a published check catalogue — at which point this page will say so and the status will change.

How it differs from the analysis you already have

Type	Reads	Needs the app running	Guardian status
Source and configuration	The project as written	No	Verified command surface
Binary artefact	The built file you ship	No	Command group present, checks not published
Dynamic	Behaviour at runtime	Yes	Experimental

Prerequisites

Dynamic analysis needs a running application, which means it needs an environment to run it in. Depending on the platform that is a physical device, an emulator or a simulator you control. Some workflows in this category also involve intercepting traffic, which needs additional local setup.

The exact prerequisites for Guardian’s command group are not documented, and this page will not guess at them. Check the group’s own help against your installed build:

Terminal

guardian --help

Whatever you run, it runs on your machine against an application you supply. Nothing is uploaded.

Authorization and scope

Use a test build and test accounts, never production credentials.
Do not point runtime analysis at a production backend. A local or staging environment is the correct target.
Runtime output can contain live request and response data. Treat any capture as sensitive and delete it when you are done.

Conceptual workflow

Establish authorization and scope.
In writing, before anything runs.
Prepare an environment you control.
A device, emulator or simulator, and a non-production backend.
Install and launch a test build.
Built from the same source you reviewed statically.
Exercise the application while observing.
Runtime analysis only sees what actually runs, so coverage depends entirely on what you exercise.
Treat the output as exploratory.
Investigate what it suggests. Do not attach it to a release decision.

If it does not work

That is the expected outcome often enough that it is documented rather than surprising. Thetroubleshooting entry covers missing prerequisites. In the meantime, source and configuration analysis is the part of Guardian that is ready to depend on.