References and Expressions

When References Are Resolved

Source References

Use ${source::...} to reference a source output table.

leftTable: ${source::monitors.network.discovery.sources.ports}
rightTable: ${source::monitors.network.discovery.sources.aliases}

Column and Entry References

Column references are positional and 1-based:

attributes:
  id: $1
  name: $2

These positions refer to the current table shape at that pipeline stage.

• $1 = first column of the current row
• $2 = second column of the current row
• $3 = third column of the current row

If computes add, remove, or reorder columns, these references must be updated accordingly.

The example below shows the same row as a table and as serialized text:

disk01;SSD;ok

File References

Use ${file::<relative-path>} for embedded scripts/files in connector folder.

script: ${file::fan-info.awk}
commandLine: /bin/sh ${file::collector.sh}

Translation References

Use ${translation::<tableName>} with translate/arrayTranslate/perBitTranslation.

translationTable: ${translation::SensorStatusTable}

Constant References

Use ${constant::<constantName>} for reusable literal values.

hw.parent.id: ${constant::_DEVICE_ID}

Connector Variable References

Use ${var::<variableName>} for user-configurable values declared under connector.variables (each with a description and a defaultValue):

commandLine: /usr/bin/ps -e -o comm,args | grep -E "${var::matchName}"

Variables are substituted at connector load time, from the defaultValue or from the user's additionalConnectors configuration. Always declare a defaultValue: with neither a default nor a configured value, the literal ${var::name} survives unresolved. See Reuse and Configuration^[1] for declaration and configuration details.

Protocol and Resource Attribute References

value: ${protocol::jmx.port}
header: "Authorization: Bearer ${resource.attribute::api.token}"

• ${protocol::<type>.<property>} accesses configured protocol data.
• ${resource.attribute::<key>} accesses host/resource-level attributes.

Mono-Instance Attribute References

Use ${attribute::<key>} in mono-instance contexts: monoInstance collect jobs run once per discovered instance, and this reference injects that instance's attributes (as mapped during discovery) into the source. See Monitors and Jobs^[2].

commandLine: /bin/sh ${file::detail.sh} ${attribute::id}

An attribute comes from the monitored host and may hold spaces or quotes, like a file or process name. Escape it for the syntax around it with the same esc(TYPE):: prefix as the credential macros, ${esc(TYPE)::attribute::<key>}, which also applies to ${esc(TYPE)::resource.attribute::<key>} and to the tool parameters, ${esc(TYPE)::param::<name>}:

commandLine: /bin/sh ${file::detail.sh} '${esc(bash)::attribute::id}'
query: SELECT Name FROM Win32_Service WHERE Name = '${esc(wql)::attribute::name}'

Each type escapes the inside of a string of its syntax, the quotes being written in the connector (see the table under Credential Macros below): bash is for the inside of single quotes, '${esc(bash)::attribute::id}', where the shell expands nothing. The value then stays one word, but the command receiving it still reads it: an attribute starting with - (a file named -rf) would be an option, so write -- before a positional value where the command supports it (rm -- '${esc(bash)::attribute::path}'), and never pass a value to a command that runs it as code (eval, sh -c, find -exec…). A value that would form a credential macro (%{...}) with the text around it is not inserted.

Inline AWK Expressions

Use ${awk::...} for concise expression-level formatting.

name: ${awk::sprintf("%s (%s)", $2, $3)}

References in Compute Attributes

${resource.attribute::<attribute-key>}

${protocol::<protocol-type>.<property>}

${source::<source-name>}

sources:
  source(1):
    type: http
    path: /api/device
    computes:
      - type: replace
        column: 1
        existingValue: "PORT"
        newValue: ${protocol::http.port}

sources:
  source(1):
    type: http
    path: /api/device
    computes:
      - type: append
        column: 1
        value: " - ${source::monitors.enclosure.simple.sources.source_discovery}"

sources:
  source(1):
    type: http
    path: /api/hosts
    computes:
      - type: keepOnlyMatchingLines
        column: 3
        valueList: "https://${resource.attribute::host.name}"

Runtime Credential Macros (%{...})

%{...} macros inject the resource's configured credentials at execution time. They work in HTTP sources and criteria (url, path, header, body, authenticationToken) and in command lines (SSH/local/WMI):

header: "Authorization: Basic %{BASIC_AUTH_BASE64}"

To escape the injected value for the surrounding syntax, wrap the macro as %{esc(TYPE)::MACRO} where TYPE is one of json, xml, url, regex, windows, cmd, powershell, linux, bash, sql, wql:

body: '{ "user": "%{esc(json)::USERNAME}", "password": "%{esc(json)::PASSWORD}" }'
commandLine: mytool --password '%{esc(bash)::PASSWORD}'

The same types escape the ${esc(TYPE)::...} references to attributes and parameters, wherever these references are replaced. The credential macros, expanded in HTTP fields and command lines only, are not expanded in a SQL or WQL query nor in the regular expressions of a source: the sql, wql and regex types serve the references there.

Most types escape the inside of a string of their syntax, the quotes being written in the connector:

The tools^[3] section lists which escape each field of a tool takes, and what the review of a tool checks.

The related %{SUDO:command} macro (command elevation) is tied to the connector's sudoCommands list — see Reuse and Configuration^[1].

Serialization Side Effects (Advanced but Important)

Tables are internally list-of-list-of-strings, but many transformations pass through semicolon-separated serialized rows. Because semicolon is the column separator, appending ;value to a column payload can effectively create a new materialized column once the row is re-parsed.

Example:

# original row
node01;ClusterA;ok

# after append on column 2 with value ';PowerStore'
node01;ClusterA;PowerStore;ok

Use this behavior intentionally and carefully; it is powerful but easy to misuse.

Common Mistakes

• broken source paths when refactoring monitor names
• using relative source references where absolute references are required
• mixing positional columns after compute pipeline changes without remapping
• embedding secrets directly instead of protocol/resource references