Interface Cluster

The Software Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that may be used by a Node to assist a user or Administrator in diagnosing potential problems. The Software Diagnostics Cluster attempts to centralize all metrics that are relevant to the software that may be running on a Node.

SoftwareDiagnosticsCluster supports optional features that you can enable with the SoftwareDiagnosticsCluster.with() factory method.

See

MatterSpecification.v13.Core § 11.13

interface Cluster {
    attributes: Merge<{
        currentHeapFree: OptionalAttribute<number | bigint, any>;
        currentHeapUsed: OptionalAttribute<number | bigint, any>;
        threadMetrics: OptionalAttribute<TypeFromFields<{
            id: FieldType<number | bigint>;
            name: OptionalFieldType<string>;
            stackFreeCurrent: OptionalFieldType<number>;
            stackFreeMinimum: OptionalFieldType<number>;
            stackSize: OptionalFieldType<number>;
        }>[], any>;
    }, GlobalAttributes<{
        watermarks: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        softwareFault: OptionalEvent<TypeFromFields<{
            faultRecording: OptionalFieldType<Uint8Array>;
            id: FieldType<number | bigint>;
            name: OptionalFieldType<string>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                currentHeapHighWatermark: Attribute<number | bigint, any>;
            };
            commands: {
                resetWatermarks: Command<void, void, any>;
            };
        };
        flags: {
            watermarks: true;
        };
    }];
    features: {
        watermarks: BitFlag;
    };
    id: Branded<52, "ClusterId">;
    name: "SoftwareDiagnostics";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    currentHeapFree: OptionalAttribute<number | bigint, any>;
    currentHeapUsed: OptionalAttribute<number | bigint, any>;
    threadMetrics: OptionalAttribute<TypeFromFields<{
        id: FieldType<number | bigint>;
        name: OptionalFieldType<string>;
        stackFreeCurrent: OptionalFieldType<number>;
        stackFreeMinimum: OptionalFieldType<number>;
        stackSize: OptionalFieldType<number>;
    }>[], any>;
}, GlobalAttributes<{
    watermarks: BitFlag;
}>>

Type declaration

  • ReadonlycurrentHeapFree: OptionalAttribute<number | bigint, any>

    The CurrentHeapFree attribute shall indicate the current amount of heap memory, in bytes, that are free for allocation. The effective amount may be smaller due to heap fragmentation or other reasons.

    See

    MatterSpecification.v13.Core § 11.13.6.2

  • ReadonlycurrentHeapUsed: OptionalAttribute<number | bigint, any>

    The CurrentHeapUsed attribute shall indicate the current amount of heap memory, in bytes, that is being used.

    See

    MatterSpecification.v13.Core § 11.13.6.3

  • ReadonlythreadMetrics: OptionalAttribute<TypeFromFields<{
        id: FieldType<number | bigint>;
        name: OptionalFieldType<string>;
        stackFreeCurrent: OptionalFieldType<number>;
        stackFreeMinimum: OptionalFieldType<number>;
        stackSize: OptionalFieldType<number>;
    }>[], any>

    The ThreadMetrics attribute shall be a list of ThreadMetricsStruct structs. Each active thread on the Node shall be represented by a single entry within the ThreadMetrics attribute.

    See

    MatterSpecification.v13.Core § 11.13.6.1

base

base: undefined

commands

commands: {}

events

events: {
    softwareFault: OptionalEvent<TypeFromFields<{
        faultRecording: OptionalFieldType<Uint8Array>;
        id: FieldType<number | bigint>;
        name: OptionalFieldType<string>;
    }>, any>;
}

Type declaration

extensions

extensions: readonly [{
    component: {
        attributes: {
            currentHeapHighWatermark: Attribute<number | bigint, any>;
        };
        commands: {
            resetWatermarks: Command<void, void, any>;
        };
    };
    flags: {
        watermarks: true;
    };
}]

features

features: {
    watermarks: BitFlag;
}

Type declaration

  • Readonlywatermarks: BitFlag

    Watermarks

    Node makes available the metrics for high watermark related to memory consumption.

id

id: Branded<52, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              currentHeapFree: OptionalAttribute<number | bigint, any>;
              currentHeapUsed: OptionalAttribute<number | bigint, any>;
              threadMetrics: OptionalAttribute<TypeFromFields<{
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
                  stackFreeCurrent: OptionalFieldType<number>;
                  stackFreeMinimum: OptionalFieldType<number>;
                  stackSize: OptionalFieldType<number>;
              }>[], any>;
          };
          events: {
              softwareFault: OptionalEvent<TypeFromFields<{
                  faultRecording: OptionalFieldType<Uint8Array>;
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentHeapHighWatermark: Attribute<number | bigint, any>;
                  };
                  commands: {
                      resetWatermarks: Command<void, void, any>;
                  };
              };
              flags: {
                  watermarks: true;
              };
          }];
          features: {
              watermarks: BitFlag;
          };
          id: 52;
          name: "SoftwareDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              currentHeapFree: OptionalAttribute<number | bigint, any>;
              currentHeapUsed: OptionalAttribute<number | bigint, any>;
              threadMetrics: OptionalAttribute<TypeFromFields<{
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
                  stackFreeCurrent: OptionalFieldType<number>;
                  stackFreeMinimum: OptionalFieldType<number>;
                  stackSize: OptionalFieldType<number>;
              }>[], any>;
          };
          events: {
              softwareFault: OptionalEvent<TypeFromFields<{
                  faultRecording: OptionalFieldType<Uint8Array>;
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentHeapHighWatermark: Attribute<number | bigint, any>;
                  };
                  commands: {
                      resetWatermarks: Command<void, void, any>;
                  };
              };
              flags: {
                  watermarks: true;
              };
          }];
          features: {
              watermarks: BitFlag;
          };
          id: 52;
          name: "SoftwareDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentHeapFree?: number | bigint;
          currentHeapUsed?: number | bigint;
          threadMetrics?: {
              id: number | bigint;
              name?: string;
              stackFreeCurrent?: number;
              stackFreeMinimum?: number;
              stackSize?: number;
          }[];
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              currentHeapFree: OptionalAttribute<number | bigint, any>;
              currentHeapUsed: OptionalAttribute<number | bigint, any>;
              threadMetrics: OptionalAttribute<TypeFromFields<{
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
                  stackFreeCurrent: OptionalFieldType<number>;
                  stackFreeMinimum: OptionalFieldType<number>;
                  stackSize: OptionalFieldType<number>;
              }>[], any>;
          };
          events: {
              softwareFault: OptionalEvent<TypeFromFields<{
                  faultRecording: OptionalFieldType<Uint8Array>;
                  id: FieldType<number | bigint>;
                  name: OptionalFieldType<string>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentHeapHighWatermark: Attribute<number | bigint, any>;
                  };
                  commands: {
                      resetWatermarks: Command<void, void, any>;
                  };
              };
              flags: {
                  watermarks: true;
              };
          }];
          features: {
              watermarks: BitFlag;
          };
          id: 52;
          name: "SoftwareDiagnostics";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            currentHeapFree: OptionalAttribute<number | bigint, any>;
            currentHeapUsed: OptionalAttribute<number | bigint, any>;
            threadMetrics: OptionalAttribute<TypeFromFields<{
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
                stackFreeCurrent: OptionalFieldType<number>;
                stackFreeMinimum: OptionalFieldType<number>;
                stackSize: OptionalFieldType<number>;
            }>[], any>;
        };
        events: {
            softwareFault: OptionalEvent<TypeFromFields<{
                faultRecording: OptionalFieldType<Uint8Array>;
                id: FieldType<number | bigint>;
                name: OptionalFieldType<string>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentHeapHighWatermark: Attribute<number | bigint, any>;
                };
                commands: {
                    resetWatermarks: Command<void, void, any>;
                };
            };
            flags: {
                watermarks: true;
            };
        }];
        features: {
            watermarks: BitFlag;
        };
        id: 52;
        name: "SoftwareDiagnostics";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods