Using the Overwatch service¶
The Overwatch service provides JSON-based remote introspection of a running Kanzi application.
It exposes the scene graph, node properties, resources, textures, render passes, screen capture, performance metrics, data sources, logs, and trace capture through a set of overwatch.* commands.
You can use these commands from the local console, the remote TCP console, or the serial console. They are also the foundation for the Monitor Web UI, which provides a browser-based interface for visual debugging.
Platform support¶
The Overwatch service builds from sources on all known Kanzi target platforms.
How the Overwatch service works¶
The Overwatch service registers overwatch.* commands with the Command Processor service.
Each command queries the Kanzi Engine and returns a single-line JSON response through the standard console protocol.
Property modification (overwatch.setprop) and data modification (overwatch.setdata) are enabled by default. To disable them and operate in read-only mode, set OverwatchPropertyChangeEnabled = 0 in the configuration file.
Screenshot capture uses a two-phase protocol: the first call schedules a capture for the next RenderStage callback (because commands run before rendering, leaving framebuffer 0 empty at command time). The client polls until the image is ready.
Setting up the Overwatch service¶
The Overwatch service is enabled by default. To disable it, set
ServiceOverwatchEnabled = 0inkanzimonitor.cfg.Property editing is enabled by default. To disable it, set
OverwatchPropertyChangeEnabled = 0inkanzimonitor.cfg.Start the application and connect using the remote console, local console, or Monitor Web UI.
Send
overwatch.*commands and receive JSON responses.
Querying service status¶
overwatch Show Overwatch service status
overwatch.status Get Overwatch service status as JSON (includes
buildConfig).
Working with the node tree and properties¶
overwatch.nodes [maxDepth] Get node tree as JSON. Optional depth limit.
overwatch.props <node_path> [precedence=local|all]
Get a node's locally-set property values as JSON.
overwatch.setprop <path> <property> <value> Set a property value on a node.
The node path uses / separators matching the Kanzi node hierarchy (for example, Viewport 2D/Scene/Text Block 3D). You can quote paths and values that contain spaces.
overwatch.setprop requires OverwatchPropertyChangeEnabled = 1.
Setting a property value¶
overwatch.setprop takes the property’s data type from the engine-wide property type registry, the same registry overwatch.propertytypes lists, and parses the value according to that type. Pass the qualified name — TextConcept.HorizontalPadding, not HorizontalPadding — because that is what the registry is keyed by. An unqualified name that matches one or more qualified types is reported with those names as candidates.
Data type |
Value format |
Example |
|---|---|---|
|
a whole number |
|
|
a number, with or without a decimal point |
|
|
|
|
|
text, quoted if it contains spaces |
|
|
|
|
|
|
|
|
|
|
|
|
|
Resource, pointer, Matrix3x3, Matrix4x4 and range properties cannot be set with this command; it reports the type it resolved and which types are supported.
The response names the resolved type and where that type came from:
{"success":true,"path":"…","property":"TextConcept.HorizontalPadding","type":"Vector2","typeSource":"registry","value":"4,0","requested":"4,0"}
|
What it means |
|---|---|
|
The property type is registered in the process and its declared type was used. The normal case. |
|
The name is not in the registry, but this node has a property storage entry for it — an unregistered property type. |
|
Nothing knows the name, so the type was guessed from the shape of the value. A guess, and usually a sign of a misspelled or unqualified name. |
A value that does not parse is rejected and the error names the expected format for the resolved type. Nothing is written in that case, which matters for bool: a misspelled true is an error rather than a silent false.
Understanding what overwatch.props reports¶
overwatch.props reports the properties a project set on a node — through Kanzi Studio, through a binding, or through overwatch.setprop. Each entry carries a precedence field naming the level that supplies its value, and by default every entry reads "precedence":"local".
Kanzi resolves a property value from several input sources, in a fixed order of precedence — a modified value, then the local value, then a named or typed style, then an inherited value, then the class default value. See Property precedence in the Kanzi documentation. precedence names which of those levels the reported value came from.
This is narrower than what the node holds. Kanzi has no way to enumerate “the properties this node can have”; the only thing it enumerates is the node’s property storage, and storage answers a different question — what the node has machinery for. Kanzi creates storage whenever anything needs it: a local value, a style, a modifier, a notification handler, or a property flag. Storage is therefore a superset of the set values, and it can outlive the value that caused it.
Kanzi Monitor enumerates storage because nothing else enumerates, then classifies each entry and reports only the local ones. What it leaves out is not dropped silently — the response ends with a storage object counting every entry by precedence:
"storage":{"entries":16,"local":10,"style":0,"modified":0,"classDefault":3,"none":3}
The counts always sum to entries, so you can see at a glance how much of a node’s storage is not a set value.
|
What it means |
|---|---|
|
A value the project set: |
|
A named or typed style supplies the value. A value source above class precedence that is not the local value. |
|
A modifier is the only input into the value: an animation, a modifier binding, or a state manager state. |
|
The class default value is the only input. The project did not set this property. |
|
Storage exists but nothing supplies a value. A notification handler, modifier storage, or a property flag needed the storage. |
Pass precedence=all to see every storage entry, each labelled:
overwatch.props "/Screen/RootNode/Viewport 2D/Scene/Text Block 3D" precedence=all
Note
A none entry reports "value":null. That means no readable value exists, not that the property is set to null. TextConcept.FontColor on a stock TextBlock3D is one: it appears in storage because something registered interest in it, and it has never been set.
Note
An inherited value is reported on the ancestor that sets it, as a local value — not on the descendant that displays it. Kanzi resolves an inheritable property by walking up the ancestors when the value is read, so the descendant gets no value input of its own, and overwatch.props on the descendant reports the property as none or classDefault, or omits it entirely. A list box item whose text is bound through an inherited DataContext.DataContext shows exactly this: the bound text reads correctly, while the node’s own DataContext.DataContext reports "precedence":"none". That is not a missing data context — it is one that lives on an ancestor. To find where an inherited value comes from, query the ancestors.
Note
binding and precedence answer different questions and are reported separately. A bound property usually reads as local, because a binding writes at local precedence — but a resource binding can leave the value coming from the class default, in which case the entry carries a binding field and a precedence of classDefault. Do not read one as implying the other.
A property missing from the default listing is at its class default, or has no value at all. It is not evidence that the node cannot have that property — for that question, use overwatch.propertytypes, which lists the property types registered in the process.
Inspecting what the engine loaded¶
The commands above answer questions about instances — this node, that render pass. These answer questions about the vocabulary the process has: which kzb files are loaded, and what property types, message types and classes the engine knows.
overwatch.kzbfiles [files] [urls] [types] Get loaded kzb files as JSON.
overwatch.kzbentry <hostName> <index> <path> [maxBytes]
Get raw bytes of a kzb entry as hex.
overwatch.propertytypes [filter] [limit] [offset] Get registered property types as JSON.
overwatch.messagetypes [filter] [limit] [args] Get registered message types as JSON.
overwatch.messagetype <name> Look up one message type by exact name.
overwatch.metaclasses [filter] [limit] [offset] [props] [messages]
Get registered metaclasses as JSON.
The listings share a paging and filtering convention. filter is a case-insensitive substring of the name, and * means “everything” so that a limit can be passed positionally without narrowing the result. limit of 0 returns every match. Each response reports total, matched, returned and offset, and sets truncated and hasMore when matches exist beyond the window returned — a count is never presented as complete when it is a page.
Which surface answers which question¶
Command |
Answers |
|---|---|
|
What did the project set on this node. See Understanding what overwatch.props reports. |
|
What property types exist in this process, with their data types. Process-wide, not per node. |
|
What classes the object factory can create by name, and which property and message types each class declares. |
There is deliberately no “what properties can this node accept” listing. overwatch.props reports what a node has, and overwatch.propertytypes reports what exists — neither is a per-node schema.
kzb files¶
overwatch.kzbfiles lists the kzb files the resource manager has loaded, and the kzb format version this build parses:
{"count":3,"kzbFormatVersion":"46.0","kzbFiles":[
{"hostName":"kanziperformancetools","index":0,"projectName":"kanziperformancetools","colorWorkflow":"Standard"}, … ]}
The optional flags are opt-in payloads, because they can be large: files adds each kzb’s entries with byte sizes, urls adds resource URLs, and types adds the property types, classes and message types the kzb declares. hostName and index together address one kzb — index is the position within a host name’s group, so it is usually 0.
overwatch.kzbentry reads the raw bytes of one entry, for when a listing is not enough:
overwatch.kzbentry kanziperformancetools 0 /$message_types 16
→ {"hostName":"kanziperformancetools","index":0,"path":"/$message_types","sizeBytes":12,
"returnedBytes":12,"truncated":false,"leadingUint32LE":1,
"hex":"01 00 00 00 08 00 00 00 03 00 00 00","ascii":"............"}
Note
The internal layout of $-prefixed kzb entries is private to Kanzi and can change between releases. Read them for diagnosis, not as a format to build on.
Property types, message types and metaclasses¶
overwatch.propertytypes lists the engine-wide property type registry with a data-type histogram over every match, which is what tells you the real type of a property before setting it:
overwatch.propertytypes ClearColor 6
→ {"total":911,"matched":5,"returned":5,"dataTypeCounts":{"ColorRGBA":5},"propertyTypes":[
{"name":"ClearRenderPass.ClearColor0","unqualifiedName":"ClearColor0","dataType":"ColorRGBA",
"inherited":false,"changeFlags":0}, … ]}
overwatch.metaclasses lists the classes the object factory can create by name. Pass props or messages to include what each class declares — this is the owning-class attribution the flat property type registry cannot give:
overwatch.metaclasses ClearRenderPass 2 0 props
→ {"total":465,"matched":1,"abstractCount":0,"sealedCount":1,"metaclasses":[
{"name":"Kanzi.ClearRenderPass","base":"Kanzi.RenderPass","abstract":false,"sealed":true,
"propertyTypeCount":6,"messageTypeCount":0,"propertyTypes":[
{"name":"ClearRenderPass.ClearColor0","dataType":"ColorRGBA"}, … ]}]}
Note
overwatch.metaclasses reports the object factory registry — the types creatable by name — not every metaclass that exists. A class that is only ever instantiated programmatically is absent by design, so a type appearing in overwatch.allresources but not here is not a defect.
base is the immediate base metaclass, and it is empty for a type whose base is an unnamed concept template — Kanzi.Button2D, Kanzi.Activity2D, Kanzi.ContentLayout2D, Kanzi.CompositionTargetRenderPass and around forty others on the current baseline. A walk up the chain therefore stops early for those types. This listing answers “what types exist”, not “what derives from what”.
overwatch.messagetypes unions two sources, because neither is complete on its own — the message types metaclasses declare, and the ones each kzb declares. The response says how many came from where, and every row carries its source:
overwatch.messagetypes Button 3
→ {"total":206,"matched":10,"returned":3,"truncated":true,"metaclassesScanned":465,
"kzbDeclaredCount":1,"routingCounts":{"TunnelingBubbling":10},"messageTypes":[
{"name":"Message.Button.Click","routing":"TunnelingBubbling","source":"metaclass",
"argumentsClass":"Kanzi.ButtonConcept.ClickedMessageArguments","argumentCount":0}, … ]}
Pass args to include each message type’s flattened argument list.
overwatch.messagetype looks one up by exact name. The registry can only be queried by name, which is why the listing above has to union two walks instead of iterating it:
overwatch.messagetype Message.Button.Click
→ {"name":"Message.Button.Click","found":true,"registeredName":"Message.Button.Click",
"routing":"TunnelingBubbling","argumentsClass":"Kanzi.ButtonConcept.ClickedMessageArguments",
"listedByMessageTypes":true}
listedByMessageTypes tells you whether overwatch.messagetypes also reaches it, which is what distinguishes a type that is merely unlisted from one that is genuinely unregistered.
Querying resources and memory¶
overwatch.resources Get all loaded resources as JSON with memory info.
overwatch.allresources [name_filter] Get all resources (created and loaded) as JSON.
Optional name filter.
overwatch.resourceinfo <index> Get detailed resource info as JSON. For textures,
textureInfo includes type, faceCount, sliceCount,
and isCubemap.
overwatch.purge Purge unused resources from the ResourceManager.
Previewing textures and graphics¶
overwatch.texturepreview <index> [maxDim] [gpu] [face=<n>]
Get texture preview as base64 RGBA.
overwatch.framebuffers Get all FBO-backed render-target textures
as JSON.
overwatch.screenshot [maxDim] [outputIndex] Capture default framebuffer (FBO 0)
as base64 RGBA.
overwatch.texturepreview returns a downscaled RGBA image of the texture at the given resource index. The optional maxDim parameter limits the longest dimension (default: 256). The optional gpu flag forces GPU readback for textures that only exist on the GPU. The optional face=<n> argument selects a single cubemap face, where n is 0–5 in the order +X, -X, +Y, -Y, +Z, -Z (default: 0). The response includes face and faceCount fields.
All image commands (overwatch.texturepreview, overwatch.screenshot, overwatch.renderpasspreview, and the capture.* commands of Using the Capture Service) return raw RGBA data. The image is vertically flipped relative to screen orientation because GPU framebuffer readback data is bottom-up. Flip the image vertically before display.
overwatch.screenshot uses a two-phase capture protocol. The first call schedules the capture for the next render frame and returns {"status":"pending"}. The client polls with the same command until the image is ready, at which point it returns the base64-encoded RGBA data.
The capture is taken inside the render stage, so an application that is not rendering cannot produce one. Each pending response therefore reports waitedMs, framesRendered and deadlineMs, and after the deadline the request is abandoned and answered with an error instead of staying pending indefinitely. framesRendered is always 0 in a pending answer, and that is not a bug: the capture happens inside the render stage with no early return, so if a frame had rendered the request would already be complete rather than pending. The number that moves is mainLoopFrames, the scheduler frames since the request — it climbs even when nothing is drawing. So mainLoopFrames climbing with framesRendered at 0 means the main loop is alive but not rendering (minimised, idle-suspended, or a host whose view trees render into surfaces owned by other processes), while both at 0 means the loop itself is not turning. A request that cannot be served at all, because the graphics output does not exist, is refused immediately rather than accepted and timed out.
A successful capture reports what it captured, so a surface that has nothing to do with the application is visible as such: viewRoots lists each view root with its laid-out size, uniformColor says whether every pixel is identical, and a warning is added when the captured surface matches no view root’s size. That combination — a uniform image at a size no view root has — is what a capture of the wrong framebuffer looks like. A uniform image on its own is not conclusive, since a deliberately black screen is uniform too.
Inspecting render passes¶
overwatch.renderpasses Get render pass tree as JSON.
overwatch.renderpasspreview <index> [maxDim] Get CompositionTarget preview as base64 RGBA.
overwatch.renderpassprops <index> [precedence=local|all]
Get a render pass's property values as JSON.
overwatch.setrenderpassprop <index> <property> <value>
Set a property value on a render pass.
Reading and setting render pass properties¶
A render pass is a property object, like a node. overwatch.renderpassprops reports its properties in exactly the shape Understanding what overwatch.props reports describes for nodes — only locally-set values by default, each with its precedence, and the rest counted under storage — and overwatch.setrenderpassprop writes one, taking the data type from the property type registry and accepting the value formats listed in Setting a property value.
Both address a pass by the index that overwatch.renderpasses reports, the same index overwatch.renderpasspreview and overwatch.resourceinfo use. overwatch.setrenderpassprop requires OverwatchPropertyChangeEnabled = 1.
To find out what a pass type can carry, use overwatch.metaclasses <type> 0 0 props, which lists the property types each class declares.
The properties worth changing interactively:
Property |
Type |
What it does |
|---|---|---|
|
|
Turns the pass off. The fastest way to see what a pass contributes — pair it with |
|
|
How often the pass runs, and its phase. |
|
|
|
|
|
|
|
|
Clear values. |
|
|
Compute dispatch size. |
For example, to see what a draw pass contributes to a composition target:
overwatch.setrenderpassprop 104 RenderPass.Enabled false
overwatch.renderpasspreview 101
Note
The listing reports what a pass has set, exactly as it does for a node, so a property nothing has assigned does not appear — including RenderPass.Enabled on a pass nobody has toggled. Set it once with overwatch.setrenderpassprop, which resolves the property by name and does not need an existing value, and it appears in the listing from then on.
Note
Resource-typed properties — composition targets, textures, materials, and the OutputBuffer of a CreateGPUBufferRenderPass — cannot be set from a console string. They are reported as unsupported, naming the type. Reading them is still useful: they appear in the listing as <Resource>.
Monitoring performance¶
overwatch.perf Get performance metrics as JSON.
overwatch.watchers Get performance watchers and
available metrics as JSON.
overwatch.addwatcher <metric> <below|above> <threshold> <cmd> Add a performance watcher.
overwatch.removewatcher <id> Remove a performance watcher
by ID.
overwatch.resetwatcher <id> Reset a triggered watcher back
to active.
overwatch.clearwatchers Remove all performance watchers.
overwatch.perf returns per-frame rendering statistics using Kanzi 4.0 metric names (drawCount, drawnElements, imageCount, framebufferCount, renderPipelineCount, constantDataCount, renderPassCount, renderPipelineBindCount, computeDispatchCount). For backward compatibility, the old metric names (batchCount, triangleCount, textureSwitches, framebufferSwitches, shaderSwitches, uniformsSent) are also included with the same values.
The response also includes a gpuObjects array with all 16 GPU object types (current, maximum, lifetime, increase, decrease counts) and a stagingBuffers array with per-buffer memory usage.
Note
Rendering statistics and GPU object counts require the Kanzi graphics statistics layer.
In Debug builds this is enabled by default; in Release and Profiling builds, set
GraphicsStatisticEnabled = true in application.cfg or
configuration.graphicsStatisticsEnabled = true in onConfigure().
See Built-in metrics for details.
Performance watchers integrate with the Performance service. See Using performance watchers.
Capturing traces and logs¶
overwatch.trace Capture a Monitor profiling trace and write to
file(s). The format(s) depend on which writers
are active — chrometrace produces .json, perfetto
produces .perfetto-trace.
overwatch.fetchtrace Fetch the most recently captured chrometrace
(.json) trace as a JSON string. Returns an error
pointing at fetchperfettotrace if only the
perfetto writer is active.
overwatch.fetchperfettotrace Fetch the most recently captured .perfetto-trace
(native Perfetto protobuf). The binary is
base64-encoded inside a JSON envelope so it can
be transported over the line-delimited protocol.
overwatch.kztrace Capture a kzTrace snapshot (engine-native tracing).
overwatch.fetchkztrace Fetch the most recently captured kzTrace as JSON.
overwatch.writers List registered trace writers as JSON.
overwatch.activatewriter <name> Activate a trace writer by name.
overwatch.deactivatewriter <name> Deactivate a trace writer by name.
overwatch.logs Get recent log entries as JSON with timestamp, level,
category, and message.
overwatch.logconfig Query log buffer configuration as JSON.
overwatch.logconfig maxentries <count> Set the log buffer size at runtime.
Kanzi Monitor supports two trace sources:
Monitor profiling trace (
overwatch.trace/overwatch.fetchtrace) – Collects profiling data through the Monitor Trace service. The output format is determined by which writers are active inActiveWriters(see Configuring Kanzi Monitor):chrometraceproduces Chrome Trace Format JSON (.json),perfettoproduces native Perfetto protobuf (.perfetto-trace), or both can be active simultaneously. In all build configurations the trace includes default registry profilers, named interval profilers, and custom collection tasks such as PerformanceInfo counters. In Profiling builds the trace additionally includes Kanzi Engine engine-internal instrumentation: main loop and startup timing, domain node/layout/render operations, and resource loading. RequiresServiceTraceEnabled = 1. See Using the Profiling Trace service for details.kzTrace (
overwatch.kztrace/overwatch.fetchkztrace) – Captures a snapshot from the Kanzi Engine tracing subsystem (kzTracescope macros). Always produces Chrome Trace Format JSON. Covers engine-internal instrumentation such as frame stages, rendering, resource loading, and node operations. Available only in Debug and Profiling builds (KANZI_TRACING_BUILD). In Release builds,overwatch.kztracereturns an error with a hint about the required build configuration. See the Tracing API reference and Tracing application configuration in the Kanzi Engine documentation.
Both outputs are compatible with Perfetto UI: drag a .json or .perfetto-trace file into the page to view it.
overwatch.fetchtrace reads the last trace file written by the Trace service and returns its full contents as a JSON string. This can be a large response (several MB). It only returns .json (chrometrace) output — when only the perfetto writer is active it returns an error pointing at overwatch.fetchperfettotrace. That command reads the most recent .perfetto-trace file (binary protobuf), base64-encodes the bytes, and emits a JSON envelope of the form {"file":"<name>.perfetto-trace","size":<bytes>,"data":"<base64>"}; the Web UI and MCP server decode the base64 on receipt. overwatch.fetchkztrace works the same way as fetchtrace for kzTrace files.
The trace writers are themselves inspectable and controllable at runtime through three additional commands — overwatch.writers (lists all registered writers with name, description, and active state as JSON), overwatch.activatewriter <name>, and overwatch.deactivatewriter <name>. See Using the Profiling Trace service for the registry model and built-in writer reference.
Working with data sources¶
overwatch.datasources Get all DataSources and their DataObject
trees as JSON.
overwatch.setdata <datasource> <path> <value> Set a DataObject value.
overwatch.datasources serializes DataObjectList nodes with a type of list, an itemCount field, and an items array containing each list item’s data.
Use the #index path syntax to address items inside a DataObjectList. For example, to set the name of the first contact in a list:
overwatch.setdata MyDataSource Root/contacts/#0/name "Alice"
overwatch.setdata requires OverwatchPropertyChangeEnabled = 1.
Inspecting fonts and glyph caches¶
overwatch.fonts Get all active FontRuntimes as JSON with
font identity, style definition, glyph cache
state, font metrics, and node usage.
overwatch.glyphcachepreview <index> [maxDim] Get glyph cache texture preview as base64
RGBA. The index refers to a font entry from
overwatch.fonts.
overwatch.setglyphcachesize <width> <height> Set glyph cache texture size for newly
created caches. Existing caches retain their
current size. Requires OverwatchPropertyChangeEnabled.
Font inspection requires a registered node tree. When the node tree is not available, overwatch.fonts returns "nodeTreeAvailable":false with an empty font list, and overwatch.glyphcachepreview returns an error message.
The overwatch.fonts response includes a uniqueCacheCount field and a deduplicated totalGpuMemory total. When the glyph cache size has been overridden, a configuredGlyphCacheSize object is included.
Overriding the glyph cache size with overwatch.setglyphcachesize lets you pressure-test glyph cache behavior — for example, forcing cache eviction or measuring the GPU memory impact of a larger atlas — without recompiling the application.
Querying graphics information¶
overwatch.graphics Get graphics and GPU information as JSON (backend,
device, API version, driver version, features).
Understanding the JSON response format¶
All overwatch.* commands return a single line of compact JSON. The console protocol uses empty lines as message delimiters, so responses do not contain newlines.
Example request and response over the remote console:
overwatch.perf
{"fps":60.0,"appFps":60.0,"frameTime":16.6,"animTime":0.5,"batches":42,"triangles":15234,...}
Floating-point values that are not finite are reported as null. JSON has no literal for inf, -inf, or NaN, and a property can legitimately hold one — GridListBoxConcept.CalculatedOffset is infinite for a list item that has not been scrolled yet — so writing the value verbatim would make the whole response unparseable. This applies to every property type that carries floats: scalars, ColorRGBA, Vector2/3/4, Matrix3x3/4x4, and SRT2D/3D.
Available commands¶
Command |
Description |
|---|---|
|
Shows Overwatch service status. |
|
Gets Overwatch service status as JSON. |
|
Gets node tree as JSON. Usage: |
|
Gets a node’s locally-set property values as JSON, each with its |
|
Sets a property value, taking the data type from the property type registry. Usage: |
|
Gets the loaded kzb files as JSON, with the kzb format version. Usage: |
|
Gets the raw bytes of one kzb entry as hex. Usage: |
|
Gets the engine-wide property type registry as JSON, with a data-type histogram. Usage: |
|
Gets the registered message types as JSON, unioning metaclass-declared and kzb-declared types and naming each row’s source. Usage: |
|
Looks up one message type by exact name. Usage: |
|
Gets the classes the object factory can create by name, optionally with the property and message types each declares. Usage: |
|
Gets loaded resources as JSON. |
|
Gets all resources as JSON. Usage: |
|
Gets resource info as JSON. Usage: |
|
Gets texture preview as base64 RGBA. Usage: |
|
Gets FBO-backed textures as JSON. |
|
Captures screen as base64 RGBA. Usage: |
|
Gets render pass tree as JSON. |
|
Gets render pass preview as base64 RGBA. Usage: |
|
Gets a render pass’s locally-set property values as JSON, each with its |
|
Sets a property value on a render pass, taking the data type from the property type registry. Usage: |
|
Gets performance metrics as JSON. |
|
Gets watchers and metrics as JSON. |
|
Adds a performance watcher. Usage: |
|
Removes a watcher. Usage: |
|
Resets a triggered watcher. Usage: |
|
Removes all watchers. |
|
Captures a Monitor profiling trace and writes a file per active writer ( |
|
Fetches the last Monitor profiling |
|
Fetches the last Monitor profiling |
|
Captures a kzTrace snapshot (engine-native tracing, requires Debug or Profiling build). |
|
Fetches the last kzTrace as JSON. |
|
Lists registered trace writers as JSON with |
|
Activates a trace writer by name. Usage: |
|
Deactivates a trace writer by name. Usage: |
|
Gets recent log entries as JSON. |
|
Gets or sets log buffer configuration. Usage: |
|
Gets graphics information as JSON. |
|
Gets DataSource trees as JSON. |
|
Sets a DataObject value. Usage: |
|
Gets active FontRuntimes as JSON with style, glyph cache, metrics, and node info. |
|
Gets glyph cache texture preview as base64 RGBA. Usage: |
|
Sets glyph cache texture size for new caches. Usage: |
|
Purges unused resources. |