LogoLogo
StackState.comDownloadSupportExplore playground
StackState v5.1
StackState v5.1
  • Welcome to the StackState docs!
  • StackState self-hosted v5.1 docs
  • Getting Started
  • 🚀Setup
    • Install StackState
      • Requirements
      • Kubernetes / OpenShift
        • Kubernetes install
        • OpenShift install
        • Required Permissions
        • Non-high availability setup
        • Override default configuration
        • Configure storage
        • Configure Ingress
        • Install from custom image registry
        • Migrate from Linux install
      • Linux
        • Before you install
        • Download
        • Install StackState
        • Install with production configuration
        • Install with development configuration
        • Install with POC configuration
        • Set up a reverse proxy
        • Set up TLS without reverse proxy
      • Initial run guide
      • Troubleshooting
    • Upgrade StackState
      • Steps to upgrade
      • Version specific upgrade instructions
      • StackPack versions
      • StackState release notes
    • StackState Agent
      • About StackState Agent V3
      • Docker
      • Kubernetes / OpenShift
      • Linux
      • Windows
      • Advanced Agent configuration
      • Use an HTTP/HTTPS proxy
      • Agent V1 (legacy)
      • Migrate Agent V1 to Agent V2
        • Linux
        • Docker
    • StackState CLI
      • CLI: sts
      • CLI: stac (deprecated)
      • Comparison between CLIs
    • Data management
      • Backup and Restore
        • Kubernetes backup
        • Linux backup
        • Configuration backup
      • Data retention
      • Clear stored data
  • 👤Use
    • Concepts
      • The 4T data model
      • Components
      • Relations
      • Health state
      • Layers, Domains and Environments
      • Perspectives
      • Anomaly detection
      • StackState architecture
    • StackState UI
      • Explore mode
      • Filters
      • Views
        • About views
        • Configure the view health
        • Create and edit views
        • Visualization settings
      • Perspectives
        • Topology Perspective
        • Events Perspective
        • Traces Perspective
        • Metrics Perspective
      • Timeline and time travel
      • Analytics
      • Keyboard shortcuts
    • Checks and monitors
      • Checks
      • Add a health check
      • Anomaly health checks
      • Monitors
      • Manage monitors
    • Problem analysis
      • About problems
      • Problem lifecycle
      • Investigate a problem
      • Problem notifications
    • Metrics
      • Telemetry streams
      • Golden signals
      • Top metrics
      • Add a telemetry stream
      • Browse telemetry
      • Set telemetry stream priority
    • Events
      • About events
      • Event notifications
      • Manage event handlers
    • Glossary
  • 🧩StackPacks
    • About StackPacks
    • Add-ons
      • Autonomous Anomaly Detector
      • Health Forecast
    • Integrations
      • About integrations
      • 💠StackState Agent V2
      • 💠AWS
        • AWS
        • AWS ECS
        • AWS X-ray
        • StackState/Agent IAM role: EC2
        • StackState/Agent IAM role: EKS
        • Policies for AWS
        • AWS (legacy)
        • Migrate AWS (legacy) to AWS
      • 💠Dynatrace
      • 💠Kubernetes
      • 💠OpenShift
      • 💠OpenTelemetry
        • About instrumentations
        • AWS NodeJS Instrumentation
        • Manual Instrumentation
          • Prerequisites
          • Tracer and span mappings
          • Relations between components
          • Span health state
          • Merging components
          • Code examples
      • 💠ServiceNow
      • 💠Slack
      • 💠Splunk
        • Splunk
        • Splunk Events
        • Splunk Health
        • Splunk Metrics
        • Splunk Topology
      • 💠VMWare vSphere
      • Apache Tomcat
      • Azure
      • Cloudera
      • Custom Synchronization
      • DotNet APM
      • Elasticsearch
      • Humio
      • Java APM
      • JMX
      • Logz.io
      • MySQL
      • Nagios
      • OpenMetrics
      • PostgreSQL
      • Prometheus
      • SAP
      • SCOM
      • SolarWinds
      • Static Health
      • Static Topology
      • Traefik
      • WMI
      • Zabbix
    • Develop your own StackPacks
  • 🔧Configure
    • Topology
      • Component actions
      • Identifiers
      • Topology naming guide
      • Topology sources
      • Create a topology manually
      • Configure topology synchronizations
      • Enable email event notifications
      • Send topology data over HTTP
      • Set the topology filtering limit
      • Use a proxy for event handlers
      • Use tags
      • Tune topology synchronization
      • Debug topology synchronization
    • Telemetry
      • Add telemetry during topology synchronization
      • Data sources
        • Elasticsearch
        • Prometheus mirror
      • Send events over HTTP
      • Send metrics data over HTTP
      • Set the default telemetry interval
      • Debug telemetry synchronization
    • Traces
      • Set up traces
      • Advanced configuration for traces
    • Health
      • Health synchronization
      • Send health data over HTTP
        • Send health data
        • Repeat Snapshots JSON
        • Repeat States JSON
        • Transactional Increments JSON
      • Debug health synchronization
    • Anomaly Detection
      • Export anomaly feedback
      • Scale the AAD up and down
      • The AAD status UI
    • Security
      • Authentication
        • Authentication options
        • File based
        • LDAP
        • Open ID Connect (OIDC)
        • KeyCloak
        • Service tokens
      • RBAC
        • Role-based Access Control
        • Permissions
        • Roles
        • Scopes
        • Subjects
      • Secrets management
      • Self-signed certificates
      • Set up a security backend for Linux
      • Set up a security backend for Windows
    • Logging
      • Kubernetes logs
      • Linux logs
      • Enable logging for functions
  • 📖Develop
    • Developer guides
      • Agent checks
        • About Agent checks
        • Agent check API
        • Agent check state
        • How to develop Agent checks
        • Connect an Agent check to StackState
      • Custom functions and scripts
        • StackState functions
        • Check functions
        • Component actions
        • Event handler functions
        • ID extractor functions
        • Mapping functions
        • Monitor functions
        • Propagation functions
        • Template functions
        • View health state configuration functions
      • Custom Synchronization StackPack
        • About the Custom Synchronization StackPack
        • How to customize elements created by the Custom Synchronization StackPack
        • How to configure a custom synchronization
      • Integrate external services
      • Mirroring Telemetry
      • Monitors
        • Create monitors
        • Monitor STJ file format
      • StackPack development
        • How to create a StackPack
        • Packaging
        • How to get a template file
        • How to make a multi-instance StackPack
        • Prepare a multi-instance provisioning script
        • Upload a StackPack file
        • Prepare a shared template
        • Customize a StackPack
        • Prepare instance template files
        • Prepare a StackPack provisioning script
        • Resources in a StackPack
        • StackState Common Layer
      • Synchronizations and templated files
    • Reference
      • StackState OpenAPI docs
      • StackState Template JSON (STJ)
        • Using STJ
        • Template functions
      • StackState Markup Language (STML)
        • Using STML
        • STML Tags
      • StackState Query Language (STQL)
      • StackState Scripting Language (STSL)
        • Scripting in StackState
        • Script result: Async
        • Script result: Streaming
        • Time in scripts
        • Script APIs
          • Async - script API
          • Component - script API
          • HTTP - script API
          • Prediction - script API
          • StackPack - script API
          • Telemetry - script API
          • Time - script API
          • Topology - script API
          • UI - script API
          • View - script API
    • Tutorials
      • Create a simple StackPack
      • Push data to StackState from an external system
      • Send events to StackState from an external system
      • Set up a mirror to pull telemetry data from an external system
Powered by GitBook
LogoLogo

Legal notices

  • Privacy
  • Cookies
  • Responsible disclosure
  • SOC 2/SOC 3
On this page
  1. Use

Glossary

StackState Self-hosted v5.1.x

PreviousManage event handlersNextAbout StackPacks

Last updated 2 years ago

Below you can find a short dictionary that can help you get a better grasp on the context of the terms used in our documentation.

  • 4T data model - Stands for Topology, Telemetry, Traces and Time. These four dimensions are the key concepts of the StackSate data model.

  • Agent - Software that runs on hosts. Collects events and metrics from hosts and sends them to StackState.

  • baseline - Information used as a starting point by which to compare other information. In StackState it's used for comparison with the metric stream. It learns from the historical data and calculates the baseline on the current data.

  • check - Defines the status of the component/relation and therefore represents the graphic presentation of the health status in the StackState view. It's responsible for determining the health status of the component based on the telemetry streams.

  • check function - Logic to determine health and run state based on the input (for example, metric stream).

  • component - The smallest unit of a topology; represents a real-life component in the IT landscape like a server, a service or an application. Each component belongs to one layer and one domain only.

  • component action - Performs an action based on a component when the user triggers the action on the quick action menu of the component.

  • component health state - Determined by all defined checks on the component. The most severe one always determines the state of the component.

  • component type - Defines the granularity level of components in the IT environment.

  • data source - Defines how StackState recognizes components of specified type during the topology creation process.

  • domain - Used to logically group components, for example, business units, teams, application.

  • element - Component or relation in the topology.

  • environment - Used to divide the IT landscape into smaller logical units according to their intended purpose. For example, creating DTAP (Develop, Test, Acceptance, Production) environments. One component can belong to multiple environments.

  • event - StackState records every change detected in the IT environment as an event. Events are always bound to one or more topology elements.

  • event handler - Performs an action defined for a specific type of event occurrence.

  • gremlin - A graph traversal language. Find out more on Gremlin .

  • groovy - A multi-faceted language for the Java platform. Find out more about Groovy .

  • health state - Representation of the health status of components and relations in the IT landscape.

  • integration - A link between an external data source and StackState as defined in a StackPack.

  • layer - Represents a hierarchy that determines the relations and dependencies in your stack - typically top to bottom.

  • log stream - A telemetry stream with log or event data coming from an external system.

  • mapping - In the synchronization process it specifies the transformation of external system topological data into StackState based on component/relation type.

  • mapping function - Allows the user to transform data before applying a template during the synchronization process.

  • metric stream - A telemetry stream with metric data coming from an external system.

  • monitor - A declarative definition of a validation rule that uses available 4T data to compute health states and attach them to the StackState Topology.

  • monitor function - Defines the underlying algorithm used to compute the health states produced by a monitor.

  • monitor runner - A subsystem of StackState responsible for execution of the logic of a monitor in a timely manner.

  • permission - Defines access to specific actions for users.

  • prefix - STQL query that's specific to a role. It's added as a query prefix to every query executed by users in that role.

  • propagation - Defines how a component affects its health state based on dependencies and relations. Health state propagates in the opposite direction of the dependency. For example, a virtual machine crash will influence applications running on it.

  • propagation function - Allows users to alter the propagation logic for a specific component.

  • relation - Models a dependency between components.

  • relation health state - Determined by all checks defined on the relation. The most severe one always determines the state of the relation.

  • role - Combination of a configured subject and a set of permissions.

  • run state - Defines the operational status of a component.

  • scope - Determines limitations for queries that user can execute. See prefix for more information.

  • selection - Filtering down the IT landscape from the full view to a more specific one. Selection can be saved as a view.

  • stack element - See element.

  • StackPack - A package that's prepared for integration with an external data source.

  • StackPack instance - Single StackPack integration to one instance of the specific type of data source.

  • state - See Health State.

  • STQL (StackState Query Language) - A built-in query language used to create advanced filters. It's a typed language, which means that each supported type of data is predefined as a part of STQL.

  • STJ (StackState Templated JSON) - A JSON file with StackState specific template placeholders.

  • subject - A user or a group with a scope.

  • synchronization - Consolidation of topology information from a data source.

  • sync - See synchronization.

  • telemetry - Defined as either logs, metrics or events.

  • telemetry data source - A real-time stream of metric or event data coming from an external system.

  • telemetry stream - Component or relation specific data collected and sent over to StackState.

  • template - Creates components/relations based on data from the topology data source.

  • topology - The set of relationships and dependencies between discrete components in an environment (for example, business services, microservices, load balancers, containers and databases).

  • topology data source - Used to provide data from an external system during the synchronization process.

  • traces - A single request that follows a certain path through the 4T data model.

  • view - A partial visualization of the 4T data model that can be tailored to show only the cut of an IT landscape that's needed.

  • view health state - Shows the health state of the entire view.

  • view state function - Allows users to modify the behavior of the view health state.

👤
here
here