This the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

  • 1:
    • 2:
      • 3:
        • 4:
          • 4.1:
            • 4.2:
              • 4.3:
                • 4.4:
                • 5:
                  • 5.1:
                    • 5.2:
                      • 5.2.1:
                        • 5.2.2:
                          • 5.2.3:
                            • 5.2.4:
                              • 5.2.5:
                                • 5.2.6:
                                • 5.3:
                                  • 5.3.1:
                                    • 5.3.2:
                                      • 5.3.3:
                                        • 5.3.4:
                                          • 5.3.5:
                                        • 6:
                                          • 6.1:
                                            • 6.2:
                                              • 6.3:
                                                • 6.4:
                                                  • 6.4.1:
                                                    • 6.4.2:
                                                  • 7:
                                                    • 7.1:
                                                      • 7.2:
                                                        • 7.3:
                                                          • 7.4:
                                                            • 7.5:
                                                              • 7.6:
                                                                • 7.7:
                                                                  • 7.8:
                                                                    • 7.9:
                                                                      • 7.10:
                                                                        • 7.11:

                                                                        Dashboards

                                                                        Sysdig users can create customized dashboards to display the most useful or relevant views and metrics for the infrastructure in a single location. This feature-rich dashboards support both form-based and PromQL-based queries and offer several user experience enhancements:

                                                                        • Multiple data queries per panel

                                                                        • Basic (form-based) and advanced (PromQL) data queries

                                                                        • Compare basic query result against historical data

                                                                        • Query support:

                                                                          • Allows to query multiple metrics

                                                                          • Render the results of a query (time series) as line, bars, stacked area, stairs, text, and so on.

                                                                          • Ability to scope and segment each query separately

                                                                          • Inherit, augment or override dashboard scope

                                                                          • Metric descriptor based units with the ability to override

                                                                          • Assign Y-axis automatically based on query unit type with the ability to override

                                                                        Each dashboard is composed of a series of panels configured to display specific data in a number of different formats. Learn more about how dashboards and panels are created, organized, and managed in the following sections:

                                                                        1 -

                                                                        About the Dashboard UI

                                                                        The main components of the Dashboard UI include widgets, time navigation, and panels.

                                                                        Widgets

                                                                        Dashboards support time series (Timechart), Histogram, Number graphs, Table, Text, and Toplist.

                                                                        Timechart and Number graph support both form-based and advanced (PromQL) queries, whereas Histogram, Table, and Toplist panels support building only form-based queries.

                                                                        Time Navigation

                                                                        Dashboard is designed around time. After a query has been executed, Sysdig Monitor polls the infrastructure data every 10 seconds and refreshes the metrics on the Dashboard panel. You select how to view this gathered data by choosing a Preset interval and a time Range.

                                                                        Presets

                                                                        Presets are a way of visualizing data that Sysdig Monitor gathers every 10 minutes. Select a preset to determine the data sample to be displayed. Overview supports the following presets:

                                                                        • 10 Seconds

                                                                        • 1 Minutes

                                                                        • 10 Minutes

                                                                        • 1 Hour

                                                                        • 6 Hour

                                                                        • 1 Day

                                                                        • 2 Weeks

                                                                        A preset that is 10 minutes or less is refreshed every 30 seconds. A preset that is greater than 10 minutes is refreshed every 1 minute.

                                                                        Presets work in conjunction with Range selections. Selecting a particular preset interval refreshes Range selection and reloads the data subsequently. For example:

                                                                        • 10 Minutes: Resets the Range to December 9, 2.20 pm - December 9, 2.30 pm.

                                                                        • 6 Hour: Resets the Range to December 9, 8.30 am - December 9, 2.30 pm.

                                                                        • 1 Day: Resets the Range to December 8, 2.30 pm - December 9, 2.30 pm.

                                                                        Range

                                                                        Range shows both date and time interval as well as the selected Presets in parenthesis. The Range indicated on the UI is determined by Presets. The time given is the closest time interval and by default, it is the current date and time preset by 1 hour.

                                                                        Click on the Range tab to open a calendar to select a range.

                                                                        See Presets to understand how Range works with Presets.

                                                                        Live

                                                                        The Live badge shows if the data shown is Live or Paused.

                                                                        • Live: the data is continuously updating based on the 10-minute polling of the Sysdig back end. The Overview feed is normally always Live.

                                                                        • Paused: When a specific row is selected, the data refresh pauses and the rows will not be updated with new data coming in.

                                                                        Time Format

                                                                        Dashboards support UTC and PDT time formats. Use the toggle button next to Range to change the time format for the slot shown in Range. The default is PDT.

                                                                        Panel Properties

                                                                        Query

                                                                        With the Dashboard, you can construct queries in two ways: Form-Based and Advanced. As you construct your query and type in a keyword in the Metrics field, auto-complete offers suggestions for the metrics in the query.

                                                                        Form-Based Query

                                                                        Use the UI fields to construct queries. Form-based data queries consist of one or multiple metrics with time and group aggregation, Segmentation, Display, Unit for both incoming data as well as displaying data on the Y-Axis, and Scope. You can choose to inherit the Dashboard scope.

                                                                        Form-based queries support both Sysdig dot notation and Prometheus-compatible underscore notation.

                                                                        PromQL Query

                                                                        The PromQL field supports only PromQL queries. Manually enter a PromQL query as follows:

                                                                        Each query starts with a group aggregator, followed by a time aggregator, then the metrics and segmentation. For example:

                                                                        sum(rate(promraw_go_memstats_heap_released_bytes_total[5m])) by(kubernetes_cluster_name)
                                                                        
                                                                        Intelligent $__interval

                                                                        You can use $__interval within a PromQL query to use the most appropriate sampling depending on the time range you have selected. This configuration ensures that the most granular data is accessible while downsampling when you select a long time range to panels load as fast as possible.

                                                                        Scope variables

                                                                        You can configure scope variables at the dashboard level to quickly filter metrics based on Cluster, Namespace, Workload, and more.

                                                                        When using PromQL queries, you can select the scope by using dynamic variables. This configuration is significant when troubleshooting as it allows you to switch context quickly without reconfiguring queries.

                                                                        Smart Autocompletion and Syntax Highlighting

                                                                        Autocomplete suggests metrics, operators, and functions, while syntax highlighting helps highlight problems within a PromQL query. This is invaluable in dynamic environments and allows you to craft the right queries faster.

                                                                        Define Axes

                                                                        Sysdig Monitor provides the flexibility to add two Y-axes on the graph. You can also determine whether you want to use them at all. Having the option to add an extra Y-axis help when you decide to add an extra query.

                                                                        Specify the following for both Y-Axis and Y-Axis Right:

                                                                        • Show: Select to show the Y-Axis on the graph.

                                                                        • Scale: Specify the scale in which you want the data to be shown on the graph.

                                                                        • Unit: Specify the unit of scale for the incoming data.

                                                                        • Display Format: Specify the unit of scale for the data to be displayed on the Y-Axis.

                                                                        • Y-Max: Specify the highest value to be displayed on the Y-Axis. Consider this as the highest point on the range. You can specify the limits as numeric values. However, the type of values that you specify must match the type of values along the axis. Y-Max should be always greater than Y-Min.

                                                                        • Y-Min: Specify the lowest value to be displayed on the Y-Axis. Consider this as the lowest point on the range. You can specify both limits or you can specify one limit and let the axes automatically calculate the other.

                                                                        Define Legend

                                                                        Determine whether you want a legend with a descriptive label for each plotted time series. Specify the location and layout. Determine the value to be displayed should be the most recently calculated data.

                                                                        For the labels, the legend uses the text you have specified in the Query Display Name and Timeseries Name fields.

                                                                        Enable Show to show the legend or create a legend if one does not exist.

                                                                        Right positions the legend in the upper right corner of the panel. Bottom positions the legend in the lower-left corner of the panel.

                                                                        Define Panel

                                                                        Specify the Panel heading and description by using the Panel tab. The description you enter appears as the panel information as follows:

                                                                        2 -

                                                                        Using PromQL

                                                                        PromQL is available only in Sysdig SaaS editions. The feature is not yet supported by Sysdig on-premises installations.

                                                                        The Prometheus Query Language (PromQL) is the defacto standard for querying Prometheus metric data. PromQL is designed to allow the user to select and aggregate time-series data.

                                                                        Sysdig Monitor’s PromQL support includes all of the features, functions, and aggregations in standard open-source PromQL. The PromQL language is documented at Prometheus Query Basics.

                                                                        For new functionalities released as part of agent v10.0.0, see Collect Prometheus Metrics.

                                                                        Construct a PromQL Query

                                                                        In the Dashboard Panel, select the PromQL type to query data using PromQL.

                                                                        • Display: Specify a meaningful display name for the legend. The text you enter replaces the metric name displayed in the legend. The default legend title is the metric name.

                                                                        • Query: Enter a PromQL query directly. For example:

                                                                          sum(rate(promraw_go_memstats_heap_released_bytes_total[5m])) by(kubernetes_cluster_name)
                                                                          

                                                                          Specify the following:

                                                                          • Metrics: Search the desired metric. The field supports auto-complete. Enter the text and the rest of the text you type is predicted so you can filter the metric easily. In the example: promraw_go_memstats_heap_released_bytes_total.

                                                                          • Segmentation: This is the process of categorizing aggregated data with labels to provide precise control over the data. Choose an appropriate value for segmenting the aggregated PromQL data. In this example, kubernetes_cluster_name.

                                                                          The PromQL query field supports the following variables. Both the variables are replaced in the UI in real-time.

                                                                          • $__range: A built-in variable. It represents the time range currently selected in the time navigation. In the Live mode, the value is constantly updated to reflect the new time range.

                                                                          • $__interval: A built-in variable. It represents a time interval and is automatically configured based on the time range.

                                                                        • Unit and Y-Axes: Specify the unit of scale and display format.

                                                                        • Compare To: (Form-Based) Allows you to compare the current value to historical values. Not supported if Segmentation is specified.

                                                                        • Axes: Determine scale, unit, display format, and gauge for the Y-axes.

                                                                        • Legend: Determine the position of the legend in the Dashboard.

                                                                        • Panel: Specify a name and add details about the panel.

                                                                          See Create a New Panel for details.

                                                                        Applying a Dashboard Scope to a PromQL Query

                                                                        The dashboard scope is automatically applied only to form-based panels. To scope a panel built from a PromQL query, you must use a scope variable within the query. The variable will take the value of the referenced scope parameter, and the PromQL panel will change accordingly.

                                                                        There are two predefined variables available:

                                                                        • $__interval represents the time interval defined based on the time range. This will help to adapt the time range for different operations, such as rate and avg_over_time, and prevent displaying empty graphs due to the change in the granularity of the data.

                                                                        • $__range represents the time interval defined for the dashboard. This is used to adapt operations like calculating average for a time frame selected.

                                                                        The following examples show how to use scope variables within PromQL queries.

                                                                        CPU Used Percent

                                                                        The following query returns the CPU used percent for all the hosts, regardless of the scope configured at the dashboard level, with a mobile average depending on the time span defined.

                                                                        avg_over_time(sysdig_host_cpu_used_percent[$__interval])
                                                                        

                                                                        To scope this query, you must set up an appropriate scope variable. A key step is to provide a variable name that is referenced as part of the query.

                                                                        In this example, hostname is used as the variable name. The host can then be referenced using $hostname as follows:

                                                                        avg_over_time(sysdig_host_cpu_used_percent{host_name=$hostname}[$__interval])
                                                                        

                                                                        Depending on the operator specified while configuring scope values, you might need to use a different operator within the query. If you are not using the correct operator for the scope type, the system will perform the query but will show a warning as the results may not be the expected ones.

                                                                        Scope Operator

                                                                        PromQL Filter Operator

                                                                        Example

                                                                        • is foo

                                                                        • is not foo

                                                                        • = : Select labels that are exactly equal to the provided string.

                                                                        • != : Select labels that are not equal to the provided string.

                                                                        sysdig_host_cpu_used_percent{host_name=$hostname}
                                                                        • in foo,bar

                                                                        • not in foo,bar

                                                                        • =~: Select labels that regex-match the provided string.

                                                                        • !~ : Select labels that do not regex-match the provided string.

                                                                        sysdig_host_cpu_used_percent{host_name=~$hostname}

                                                                        Enrich Metrics with Labels

                                                                        Running PromQL queries in Sysdig Monitor by default returns only a minimum set of labels. To enrich the return results of PromQL queries with additional labels, such as Kubernetes cluster name, you need to use a vector matching operation. The vector matching operation in Prometheus is similar to the SQL-like join operation.

                                                                        Info Metrics

                                                                        Prometheus returns different information metrics that have a value of 1 with several labels. The information that the info metrics return might not be useful as it is. However, joining the labels of an info metric with a non-info metric can provide useful information, such as the value of metric X across an infrastructure/application/deployment.

                                                                        Vector Matching Operation

                                                                        The vector matching operation is similar to an SQL join. You use a vector matching operation to build a PromQL query that can return metrics with information from your infrastructure. Vector matching helps filter and enrich labels, usually adding information labels to the metrics you are trying to visualize.

                                                                        See Mapping Between Classic Metrics and PromQL Metrics for a list of info metrics.

                                                                        Example 1: Return a Metric Filtered by Cluster

                                                                        This example shows a metric returned by an application, say myapp_guage, running on Kubernetes. The query attempts at getting an aggregated value of a cluster, by having one cluster selected in the scope. We assume that previously you have set a $cluster variable in your scope.

                                                                        To do so, run the following query to return the myapp_guage metrics:

                                                                        sum (myapp_gauge * on (container_id) kube_pod_container_info{cluster=$cluster})
                                                                        

                                                                        The query performs the following operations, not necessarily in this order:

                                                                        • The kube_pod_container_info info metrics is filtered, selecting only those timeseries and the associated cluster values you want to see. The selection is based on the cluster label.

                                                                        • The myapp_gauge metric is matched with the kube_pod_container_info metric where the container_id label has the same value, multiplying both the values. Because the info metric has the value 1, multiplying the values doesn’t change the result. As the info metric has already been filtered by a cluster, only those values associated with the cluster will be kept.

                                                                        • The resultant timeseries with the value of myapp_gauge are then aggregated with the sum function and the result is returned.

                                                                        Example 2: Calculate the GC Latency

                                                                        This example shows calculating the GC latency in a go application deployed on a specific Kubernetes namespace.

                                                                        To calculate the GC latency, run the following query:

                                                                        go_gc_duration_seconds * on (container_id,host_mac) group_left(pod,namespace) kube_pod_container_info{namespace=~$namespace}
                                                                        

                                                                        The query is performing the following operations:

                                                                        • The kube_pod_container_info info metrics are filtered based on the namespace variable.

                                                                        • The metrics associated with go_gc_duration_seconds is matched in a many-to-one way with the filtered kube_pod_container_info .

                                                                          The pod and namespace labels are added from the kube_pod_container_info metric to the result. The query keeps only those metrics that have the matching container_id and host_mac labels on both sides.

                                                                        • The values are multiplied and the resulting metrics are returned. The new metrics will only have the values associated with go_gc_duration_seconds because the info metric value is always 1.

                                                                        You can use any Prometheus metric in the query. For example, the query above can be rewritten for a sample Apache metric as follows:

                                                                        appinfo_apache_net_bytes * on (container_id) group_left(pod, namespace) kube_pod_container_info{namespace=~$namespace}
                                                                        

                                                                        Example 3: Calculate Average CPU Used Percent in AWS Hosts

                                                                        This example shows calculating the average CPU used percent per AWS account and region, having the hosts filtered by account and region.

                                                                        avg by(region,account_id) (sysdig_host_cpu_used_percent  * on (host_mac) group_left(region,account_id) sysdig_cloud_provider_info{account_id=~$AWS_account, region=~$AWS_region})
                                                                        

                                                                        The query performs the following operations:

                                                                        • Filters the sysdig_cloud_provider_info metric based on the account_id and region labels that come from the dashboard scope as variables.

                                                                        • Matches the sysdig_host_cpu_used_percent metrics with sysdig_cloud_provider_info. Only those metrics with the same host_mac label on both sides are extracted, adding region and account_id labels to the resulting metrics.

                                                                        • Calculates the average of the new metrics by account_id and region.

                                                                        Example 4: Calculate Total CPU Usage in Deployments

                                                                        This example shows calculating the total CPU usage per deployment. The value can also be filtered by cluster, namespace, and deployment by using the dashboard scope.

                                                                        sum by(cluster,namespace,owner_name) ((sysdig_container_cpu_cores_used * on(container_id) group_left(pod,namespace,cluster) kube_pod_container_info) * on(pod,namespace,cluster) group_left(owner_name) kube_pod_owner{owner_kind="Deployment",owner_name=~$deployment,cluster=~$cluster,namespace=~$namespace})
                                                                        
                                                                        • sysdig_container_cpu_cores_used can be replaced by any metric that has the container_id label.

                                                                        • To connect the sysdig_container_cpu_cores_used  metric with the pod, use kube``_pod_container_info and then, use kube``_pod_owner to connect the pod to other kubernetes objects.

                                                                        The query performs the following:

                                                                        • sysdig_container_cpu_cores_used * on(container_id) group_left(pod,namespace,cluster) kube_pod_container_info:

                                                                          • The sysdig_container_cpu_cores_used metric value is multiplied with kube_pod_container_info (which has the value of 1), by matching container_id and by keeping the pod, namespace and cluster labels as it is.

                                                                            _name_='sysdig_container_cpu_cores_used',container='<label>', container_id='<label>',container_type='DOCKER`,host_mac='<label>'
                                                                            
                                                                          • The new metrics will be

                                                                            cluster='<label>',container='<label>', container_id='<label>',container_type='DOCKER`,host_mac='<label>',namespace='<label>, pod='<label>'
                                                                            
                                                                        • The value extracted from the previous result is multiplied with kube``_pod_owner (which has the value of 1) by matching on the pod, namespace, and cluster labels and keeping the owner name from the value of kube``_pod_owner . The owner can be deployment, replicaset, service, daemonset, or statefulset object.

                                                                          • The name of the deployment to filter upon is extracted from the kube``_pod_owner metrics.

                                                                          • The pod, namespace, and cluster names are extracted from the kube_pod_container_info metrics.

                                                                        • The new metrics will be:

                                                                          cluster='<matched_label>',container='<matched_container_label>', container_id='<label>',container_type='DOCKER`,host_mac='<label>',namespace='<label>, owner_name ='<label>', pod='<label>'
                                                                          
                                                                        • The kube_pod_owner will have a label owner_name that is the name of the object that owns the pod. This value is extracted by filtering:

                                                                          kube_pod_owner{owner_kind="Deployment",owner_name=~$deployment,cluster=~$cluster,namespace=~$namespace}
                                                                          

                                                                          The owner_kind provides the deployment name and the origin of owner_name , that is the dashboard scope.

                                                                        • The sum aggregation is applied and the time series are aggregated by cluster, namespace, and deployment.

                                                                        The following table helps understand the labels applied in each step of the query:

                                                                        __name__

                                                                        container_id

                                                                        container

                                                                        container_type

                                                                        host_mac

                                                                        pod

                                                                        namespace

                                                                        cluster

                                                                        owner_name

                                                                        sysdig_container_cpu_cores_used * on(container_id) group_left(pod,namespace,cluster) kube_pod_container_info)

                                                                        No

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        No

                                                                        (sysdig_container_cpu_cores_used * on(container_id) group_left(pod,namespace,cluster) kube_pod_container_info) * on(pod,namespace,cluster) group_left(owner_name) kube_pod_owner{owner_kind="Deployment",owner_name=~$deployment,cluster=~$cluster,namespace=~$namespace}

                                                                        No

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        sum by(cluster,namespace,owner_name) ((sysdig_container_cpu_cores_used * on(container_id) group_left(pod,namespace,cluster) kube_pod_container_info) * on(pod,namespace,cluster) group_left(owner_name) kube_pod_owner{owner_kind="Deployment",owner_name=~$deployment,cluster=~$cluster,namespace=~$namespace})

                                                                        No

                                                                        No

                                                                        No

                                                                        No

                                                                        No

                                                                        No

                                                                        Yes

                                                                        Yes

                                                                        Yes

                                                                        Formatting

                                                                        Sysdig Monitor supports percentages only as 0-100 values. In calculated ratios, you can skip multiplying the whole query times 100 by selecting percentage as a 0-1 value.

                                                                        Learn More

                                                                        3 -

                                                                        Dashboard Scope

                                                                        Dashboard and panel scope defines what data is valid for aggregation and display within the dashboard. The scope can be set at a dashboard-wide level, or overridden for individual panels, by any user type except for View Only users.

                                                                        The current scope is displayed in the top left-hand corner of the module screen:

                                                                        For more information on how scopes work, refer to the Grouping, Scoping, and Segmenting Metrics documentation.

                                                                        Configure Dashboard Scope

                                                                        To configure the scope of an existing dashboard:

                                                                        1. From the Dashboard module, select the relevant dashboard from the dashboard list.

                                                                        2. Click the Edit Scope link in the top right of the module screen:

                                                                        3. Open the first level drop-down menu.

                                                                        4. Select the first level label either by clicking the desired label, or searching for the label, then clicking it.

                                                                        5. Define how the value relates to the label, and define the value.

                                                                          Scope editor restricts the scope of the selection for subsequent filters by rendering values that are specific to the selected labels. For example, if the value of the kubernetes.namespace.name label is kube-system, the values of the subsequent label, container.name will be filtered by kube-system. This means the containers rendered for filtering are only those that are part of the kube-system namespace.

                                                                        6. Optional: Dashboard Templating.

                                                                          Dashboard scope values can be defined as variables, allowing users to create a template, and use one dashboard for multiple outputs. For example, in the image below, the kubernetes.namespace.name label is set as a variable:

                                                                          Once saved, the dashboard has multiple values that can be displayed:

                                                                        7. Optional: Add additional label/value combinations to further refine the scope.

                                                                        8. Click the Save button to save the new scope, or click the Cancel button to revert the changes.

                                                                          To reset the dashboard scope to the entire infrastructure, or to update an existing dashboard’s scope to the entire infrastructure, open the first scope drop-down menu and select everywhere.

                                                                        Configure Panel Scope

                                                                        To configure the scope of an existing dashboard panel:

                                                                        1. From the Dashboard module, select the relevant dashboard from the dashboard list.

                                                                        2. Hover the cursor over the desired panel, and select the Edit (pencil) icon:

                                                                        3. Click the Override Dashboard Scope link to enable a custom panel scope.

                                                                          To return an individual panel scope to the default dashboard scope, click the Default to Dashboard Scope link, and save the changes.

                                                                        4. Open the Scope drop-down menu.

                                                                        5. Either select the new scope, or search for the desired scope, and then select it.

                                                                        6. Click the Save button to confirm the changes.

                                                                        Panels that have a custom scope (a different scope to the overall dashboard) are marked with a shaded corner:

                                                                        4 -

                                                                        Configure Dashboards

                                                                        There are two parts to creating a dashboard - creating the dashboard itself, and creating the panels that display the information.

                                                                        4.1 -

                                                                        Create a New Dashboard

                                                                        To create a dashboard with the following:

                                                                        • Using the Get Started Wizard.

                                                                        • Using a dashboard template.

                                                                          Dashboard templates are essentially immutable dashboards that can’t be edited, and the scope is fixed. You can copy them and customize as desired. See Dashboard Templates.

                                                                        • Using directly the Dashboard tab. This section helps you navigate to the default Panel editor screen.

                                                                        Get Started Wizard

                                                                        Clicking the Create Dashboard takes you to the default panel editor screen.

                                                                        Dashboard Tab

                                                                        1. On the Dashboards tab, click the Add Dashboard button.

                                                                        2. Select one of the following:

                                                                          • From Dashboard Template: Copy from a dashboard template.

                                                                          • Blank Dashboard: When you create a new dashboard, you are dropped into the panel editor. It is the default dashboard for the avg(avg(cpu.used.percent)) metrics.

                                                                        3. Specify a name for the dashboard, build a query, and save.

                                                                          For information on running queries, see the following:

                                                                          The new dashboard will now be added to the side panel under My Dashboards and is ready for configuration.

                                                                        4.2 -

                                                                        Dashboard Templates

                                                                        Sysdig provides a number of pre-built dashboards, designed around various supported applications, network topologies, infrastructure layouts, and services. These can be used to jump-start the dashboard building process, as templates for further configuration.

                                                                        Templates come with a series of panels already configured, based on the information most relevant users. The example below uses the Container dashboard template:

                                                                        The default dashboard includes number panels for CPU and Memory usage, total, in the network, and out of network bytes, and line graphs comparing in the network and out of network bytes, as well as byte usage by application/port, process, and by the host.

                                                                        To learn more, see Dashboard Templates.

                                                                        4.3 -

                                                                        Configure Dashboard Layout

                                                                        Configure Full Screen

                                                                        To view the current dashboard in full-screen mode:

                                                                        Click the Settings (three dots) icon for the dashboard, and select the Full Screen option:

                                                                        Dashboards cannot be configured in full-screen mode. They are read-only until the full-screen mode is exited.

                                                                        To exit full-screen mode, either press the ESC keyboard key or click the Exit (cross) icon.

                                                                        Configure Panel Size

                                                                        Configure Individual Panels

                                                                        The size of individual panels can be altered by moving the mouse cursor over the bottom right corner of a panel, until the diagonal resize cursor appears, pressing and holding the left mouse button, and increasing or decreasing the size of the panel by moving the cursor while pressed. The changes can be saved by clicking the Save Layout link, or reverted by clicking the Revert Changes link.

                                                                        Configure All Panels

                                                                        To configure the size of every panel in the dashboard:

                                                                        1. On the Dashboards tab, select the relevant dashboard from the left-hand panel.

                                                                        2. Click the Settings (three dots) icon for the dashboard.

                                                                        3. Select Layout to open the drop-down menu.

                                                                        4. Select the desired panel size.

                                                                        5. If the new size is correct, click the Save Layout link. Otherwise, select Revert Changes.

                                                                          Configuring this setting overrides all custom panel sizes.

                                                                        Move Panels

                                                                        To move a panel to a new position in the dashboard, move the mouse cursor over the top of the panel, until the hand cursor appears. Press and hold the left mouse button, and move the panel by moving the cursor while pressing the button. The changes can be saved by clicking the Save Layout link, or reverted by clicking the Revert Changes link.

                                                                        4.4 -

                                                                        Delete a Dashboard

                                                                        The owner or the administrator of a shared dashboard can delete it. If users duplicate that dashboard, they become the owner of the new one and are allowed to freely delete it.

                                                                        For information on access rights, see Access Levels in Dashboard.

                                                                        To delete an existing dashboard:

                                                                        1. On the Dashboard tab, select the relevant dashboard from the left-hand panel.

                                                                        2. Click the Settings (three dots) icon for the dashboard.

                                                                        3. Select Delete Dashboard.

                                                                        4. Click the Yes, Delete the Dashboard button to confirm the change.

                                                                        5 -

                                                                        Configure Panels

                                                                        Learn more about types, creating, and managing panels in the following sections:

                                                                        5.1 -

                                                                        Create a New Panel

                                                                        Sysdig Monitor supports both form-based and PromQL-based queries. You simply run a query and Sysdig Monitor builds a Dashboard that you can customize according to your preferences.

                                                                        To create a new panel, you can do one of the following:

                                                                        • Create a new dashboard.

                                                                          When you create a new dashboard, it opens to a pre-built panel. You can run a new query and build the dashboard.

                                                                        • Use a dashboard template.

                                                                          Dashboard templates are essentially immutable dashboards that can’t be edited, and the scope is fixed. You can copy them and customize as desired. See Dashboard Templates.

                                                                        • Add a new panel to an existing dashboard.

                                                                        To create a new panel:

                                                                        1. On the Dashboard tab, select the relevant dashboard from the drop-down.

                                                                        2. Click the Add Panel icon.

                                                                          The default panel editor opens up.

                                                                        3. Set up the panel:

                                                                          1. Build either a form-based query or a PromQL-based query.

                                                                          2. Define right and left Y-axes.

                                                                          3. Define the legend.

                                                                          4. Set up Panel title and description.

                                                                        4. Click Save to save the changes.

                                                                        Building a Form-Based Query

                                                                        Each type of visualization has different settings and the query fields are determined by the type. For demonstration purposes, this topic explains the steps to create a Line chart.

                                                                        1. On the Dashboards tab, click Add dashboard.

                                                                          Clicking the (+) icon opens a default panel editor.

                                                                        2. Select a visualization type.

                                                                          1. Click the Timechart tab and open the Select Visualization page.

                                                                          2. Click the desired visualization type.

                                                                          For more information on types of visualization, see Types of Panels.

                                                                        3. Select the appropriate time presets from the time navigation.

                                                                        4. Select a metric from the drop-down as follows:

                                                                          You can either scroll down or type the first few letters of the metrics. As you enter the first few letters the drop-down lists the matching entries.

                                                                        5. Specify Time Aggregation and Group Rollup.

                                                                        6. Specify the display text in the Display field.

                                                                          The text appears as a title for the legend:

                                                                        7. Specify an appropriate segmentation:

                                                                          You can enter the number of entities and the order in which they are displayed in the legend.

                                                                          Not applicable to Number panels.

                                                                        8. Specify the scope for the panel you are creating.

                                                                          You can either choose to inherit the dashboard scope as it is or apply the scope to one or all the queries.

                                                                        9. Specify the unit of scale and the display format for Y-Axis.

                                                                          Applicable only to Timeseries panels.

                                                                        10. Determine how to display null data on the dashboard.

                                                                          You can display no data as a gap, a zero value, a dotted line, or a solid line in the graph. See Display Missing Data.

                                                                        11. Optionally, compare the data against historical data.

                                                                          When segmentation is applied, comparing metrics against historical data is not supported.

                                                                        Building a PromQL Query

                                                                        To run a PromQL query:

                                                                        1. Do one of the following:

                                                                          • Click Add Dashboard if you are creating a new dashboard.

                                                                          • Click Add Panel if you are adding a new panel to an existing Dashboard.

                                                                        2. Click the PromQL button.

                                                                          The PromQL panel appears.

                                                                        3. Enter the query in the PromQL field as follows:

                                                                          In this example, the rate of memory heaps released in bytes in an interval of 5 minutes is calculated and then the total rate is calculated in each Kubernetes cluster.

                                                                        4. Select the desired time window.

                                                                        5. Specify a descriptive title for the legend and a name for the time series.

                                                                          You can specify a variable as shown in the image. The variable name is replaced with the Kubernetes cluster names in the legend.

                                                                        6. Specify the unit for incoming data and how it should be displayed.

                                                                          For example, you can specify the incoming data to be gathered in kilobytes and displayed as megabytes.

                                                                          Also, determine the location of the Y-Axis on the graph. When you have additional queries, the flexibility to place an additional Y-axis on the graph comes in handy.

                                                                        7. Determine how to display null data on the dashboard.

                                                                          You can display no data as a gap, a zero value, a dotted line, or a solid line in the graph. See Display Missing Data.

                                                                        8. Click Save to save the changes.

                                                                        5.2 -

                                                                        Types of Panels

                                                                        This topic introduces you to the types of panels in the New Dashboard.

                                                                        5.2.1 -

                                                                        Timechart Panel

                                                                        A Timechart is a graph produced by applying statistical aggregation to a label over an interval. The X-axis of a timechart will always be time.

                                                                        Timecharts allow you to see the change in metric value over time. The amount of data visualized on a graph is dependent on the time selection selected within the Dashboard. You can aggregate metrics from multiple sources into a single line, or graph a line per combination of segment labels.

                                                                        Time aggregation: For example, the average value of cpu.used.percent metric is computed for each entity over 1 hour at 1-minute intervals.

                                                                        Group Rollup: For each host.hostName the values from time aggregation are averaged over the scope and the top 10 segments are shown on the chart.

                                                                        The only supported panel type now in time series is the Line chart.

                                                                        Line Chart

                                                                        The Line panel show change over time in a selected window. Time is plotted on the horizontal axis and the change that is measured is plotted on the vertical axis.

                                                                        The image below shows the trend of resource consumption of top resource-hogging hosts in the last one hour.

                                                                        Configure Line Chart

                                                                        For information on configuring a chart, see Create a New Panel.

                                                                        Stacked Area

                                                                        An area chart is distinguished from a line chart by the addition of shading between lines.

                                                                        For information on configuring a chart, see Create a New Panel.

                                                                        5.2.2 -

                                                                        Number Panel

                                                                        Number panels allow you to view a single value for a given entity, along with optionally comparing the current value to historical values. Use the Number panel when the number is the most important aspect of the metric you’re trying to display, such as unique visitors to a website.

                                                                        Do not use this panel to see a trend, rather use it when you need to see the average of a value over the given time range. This is also useful for counting entities, such as the number of nodes in a cluster.

                                                                        For information on configuring a panel, see Create a New Panel.

                                                                        Major Features

                                                                        • The default preset for the Number visualization is 1 hour.

                                                                        • The global default values for the threshold are overridable. The new value can be reset back to the global default.

                                                                        • A comparison between two threshold values determines color-coding directions.

                                                                        • Use the No Data Display text box under the Options menu to set a custom no data text.

                                                                        • The Compare To functionality can be toggled between enabled and disabled.

                                                                        • When the Compare To value is set, the preview is updated accordingly showing the comparison value and an arrow denoting the metric has increased or decreased.

                                                                        • The unit displayed for Thresholds is determined by the query.

                                                                        5.2.3 -

                                                                        Table Panel

                                                                        The Table panel displays metric data in tabular form. In this view, you can review metric values and their associated labels in a single view. Use Table panels for such quantitative analysis where you can see actual values instead of visual representations. Similar to a spreadsheet, you can look at a combination of metric values and their segments. This is useful when you don’t necessarily care about the change in metric over time, or want to run reports to download as CSV/JSON for offline analysis.

                                                                        The panel displays the value returned by the metric query specified in the Query tab. The value is determined by the data source and the query. Each datapoint will have an associated raw and an option to add columns for additional metric values.

                                                                        Configuring Table Panel

                                                                        Major features include but not limited to :

                                                                        • Queries

                                                                          • The first query you build cannot be removed.

                                                                          • With subsequent queries are built, you cannot remove all the queries except the first one.

                                                                          • Changing the unit of the query changes the unit in the table as well.

                                                                          • Changing the display format on the query reflects on the row values.

                                                                        • Segmentation

                                                                          • The segmentation label determines the column name.

                                                                          • The segmentation in conjunction with metric values determines the values displayed on the rows.

                                                                        • Scope

                                                                          • The selected scope determines the values displayed on the table.
                                                                        • Metric / Labels Columns

                                                                          • Adding a new query insert a new column with the name of the metric as the column heading.

                                                                          • Metric values in conjunction with segmentation determine the values displayed on the rows.

                                                                        • Sorting

                                                                          • Column sorting is based on the selected column header and the type of sorting (ascending and descending).

                                                                          • When another column is sorted, the table is resorted by that column, resetting the previous sorting.

                                                                        • Resizing

                                                                          • Grab the header column by the borderline to resize the columns.

                                                                          • Browser window resizes shouldn’t reset the resize of the columns if you have resized any columns.

                                                                          • When resizing the browser window, table columns are resized to cover the full width. An exception is when you have already resized columns. In such cases, other columns that you have not resized are resized on browser window resize.

                                                                          • The last column in the table is not resizable.

                                                                        • Export

                                                                          • The table by default shows a maximum of 50 rows.

                                                                          • Clicking on Export all results… below the table opens the Export Data window.

                                                                          • Export data in either JSON or CVS format to a file. The default name of the file is the panel name. Renaming the default filename is permissible.

                                                                        For information on configuring a chart, see Create a New Panel.

                                                                        5.2.4 -

                                                                        Text

                                                                        The example below uses a text panel as a reminder list of the testing steps for a procedure.

                                                                        Text Panel Markdown

                                                                        Headers

                                                                        # H1
                                                                        ## H2
                                                                        ### H3
                                                                        #### H4
                                                                        ##### H5
                                                                        ###### H6
                                                                        
                                                                        H1
                                                                        ======
                                                                        H2
                                                                        ------
                                                                        

                                                                        Emphasis

                                                                        *italics* or _italics_
                                                                        **bold** or __bold__
                                                                        **combined _emphasis_**
                                                                        ~~strikethrough~~
                                                                        

                                                                        Lists

                                                                        1. First ordered list item
                                                                        2. Second item
                                                                          * Unordered sub-list.
                                                                            Sub-paragraph within the list item.
                                                                        1. Third item
                                                                          8. First ordered sub-list item.
                                                                        103. Fourth item
                                                                        

                                                                        General guidelines:

                                                                        • The list item number does not matter. As shown in the example below, the formatting defines the lists.

                                                                        • List items can contain properly indented paragraphs, using white space.

                                                                        • Unordered list can use: *, -, or +.

                                                                        Linebreaks

                                                                        This is the first sentence.
                                                                        
                                                                        This line is separated from the one above by two newlines, so it will be a *separate paragraph*.
                                                                        
                                                                        This line is also a separate paragraph.
                                                                        This line is only separated by a single newline, so it's a separate line in the *same paragraph*.
                                                                        

                                                                        Trailing spaces can be used for line-breaks without creating a new paragraph. This behavior is contrary to the typical GFM line break behavior, where trailing spaces are not required.

                                                                        5.2.5 -

                                                                        Toplist

                                                                        A Toplist chart displays the specified number of entities, such as containers, with the most or least of any metric value. This is useful for “ranking” metric values in order, for example, considering hosts that have the highest amount of pods running or the highest consumers of CPU or memory in your infrastructure.

                                                                        The following types of metric segmentation are supported:

                                                                        Major Features

                                                                        • Toplist supports executing only one query, however, adding a new one and deleting the existing one is allowed.

                                                                        • Segmentation is not supported for multiple metrics.

                                                                        • Text displayed on the bars in the chart is based on metrics and segmentation.

                                                                          • If a single metric is selected, segmentation text is displayed.

                                                                          • If multiple segmentations are selected, segmentation texts separated by > sign are displayed.

                                                                          • If multiple metrics are selected, the metric name is displayed.

                                                                        Segmentation

                                                                        The following types of metric segmentation are supported:

                                                                        Multi-Segmenting Single Metrics

                                                                        You can use multiple objects to simultaneously segment a single metric. For example, cpu.used.percent segmented by kubernetes.cluster.name, kubernetes.namespace.name, and kubernetes.deployment.name.

                                                                        In this example, deployments are sequentially listed in the order of resource consumption. Use Display to toggle between descending (Top) and ascending order (Bottom).

                                                                        Multi-Metrics Without Segmentation

                                                                        You can add multiple metrics to view the Toplist chart. However, segmentation is disabled for multi-metric selection.

                                                                        For information on configuring a chart, see Create a New Panel.

                                                                        5.2.6 -

                                                                        Histogram

                                                                        Sysdig Monitor handles three types of Histograms:

                                                                        • Histogram panel type on the Dashboard: Histogram panels allow you to visualize the distribution of metric values for large data collection. You should select a segmentation, and optionally, the number of buckets.

                                                                          Use Histogram for any metric, Sysdig native or custom, counter or gauge, segmented by a dimension/label. The histogram panel helps understand value across different segments. For example, CPU usage percent by pods across your cluster gives you the aggregated value across the selected time.

                                                                        • Legacy Prometheus histogram collection: This implementation of legacy Prometheus Histograms is deprecated in SaaS 3.2.6 release.

                                                                          To create a Histogram, use the Prometheus integration to collect histogram metrics and use the PromQL panel with the histogram_quantile function.

                                                                        • Prometheus histograms (collected as raw metrics): The legacy Prometheus histogram collection is replaced by the new Prometheus histogram. You can natively collect histogram metrics, and for visualization, use timechart:

                                                                          For example, run the following query to build a timechart:

                                                                          sum(histogram_metrics_bucket{kubernetes_cluster_name="prod"}) by (le)
                                                                          
                                                                          

                                                                        5.3.1 -

                                                                        Create Panel Alerts

                                                                        Alerts can be created directly from a form-based panel in a New Dashboard. If the panel has more than one query, you must select the query to use as the base for the alert.

                                                                        To create an alert:

                                                                        1. Click the More Options (three dots) icon.

                                                                        2. Select Create Alert.

                                                                        3. Configure the alert, and click the **Create **button.

                                                                        5.3.2 -

                                                                        Export Panel Data

                                                                        Table and Timechart panels in New Dashboard allow exporting data to a CSV or JSON file. This file could serve as a backup of your data or for programmatical use.

                                                                        You can export data using the following:

                                                                        • Panel menu in the New Dashboard

                                                                        • Table panel

                                                                        To export while creating or editing a Table panel:

                                                                        1. Select Table from the Visualization type.

                                                                          The panel opens to the Columns tab.

                                                                        2. Below the table, click Export all results….

                                                                          The Export Data window is displayed.

                                                                        3. Select the format.

                                                                        4. Specify a filename.

                                                                          The default name of the file is the panel name. You can rename the file that you are about to download.

                                                                        5. Click Export to save the data into the file.

                                                                          Exporting might take several minutes to complete.

                                                                        5.3.3 -

                                                                        Copy Panels to a Different Dashboards

                                                                        Copy a Single Panel

                                                                        To copy a single panel to a different dashboard:

                                                                        1. From the Explore tab, select the desired drill-down view.

                                                                        2. Hover over the desired panel, select the Settings (ellipsis) icon, and select Copy Panel.

                                                                        3. Open the drop-down menu and select the desired dashboard, or use the text-field to search through existing dashboards.

                                                                          To copy the panel to a new dashboard, enter a name for the new dashboard in the text-field instead.

                                                                        4. Click the Copy and Open button to save the changes and navigate to the configured dashboard.

                                                                        Copy All Panels

                                                                        To copy all panels in a drill-down view to a dashboard:

                                                                        1. From the Explore tab, select the desired drill-down view.

                                                                        2. Select the More Options (three dots) icon.

                                                                        3. Select Copy to Dashboard:

                                                                        4. Open the drop-down menu and select the desired dashboard, or use the text-field to search through existing dashboards.

                                                                          To copy the panel to a new dashboard, enter a name for the new dashboard in the text-field instead.

                                                                        5. Click the Copy and Open button to save the changes and navigate to the configured dashboard.

                                                                        Create a Panel Alert

                                                                        Alerts can be created directly from a dashboard panel:

                                                                        1. Click the More Options (three dots) icon.

                                                                        2. Select CreateAlert.

                                                                        3. Configure the alert, and click the Create button.

                                                                        5.3.4 -

                                                                        Duplicate a Panel

                                                                        Hover over the desired panel, click the Settings (ellipsis) icon, and select Duplicate Panel.

                                                                        5.3.5 -

                                                                        Delete an Existing Panel

                                                                        To delete a panel from a dashboard:

                                                                        1. Hover over the desired panel, click the Settings (ellipsis) icon, and select Delete Panel.

                                                                        2. Click the Yes, delete panel button to confirm, or the Cancel button to keep the panel.

                                                                        6 -

                                                                        Managing Dashboards

                                                                        This section helps you effectively use dashboards and share them with your team.

                                                                        6.1 -

                                                                        Dashboards Types

                                                                        Dashboards are organized into the following main categories

                                                                        • My Favourites: The dashboards marked as favorites by the current user.

                                                                        • Shared By My Team: Dashboards created by other users in the team and shared with the current user.

                                                                        • My Dashboards: Dashboards created by the current user.

                                                                        • Dashboard Templates: Out-of-the-box templates that you can copy and use. A dashboard created from a template inherits the template name.

                                                                        6.2 -

                                                                        Set a Default Dashboard

                                                                        A default dashboard can be configured by setting the default entry point for a team, unifying a team’s Sysdig Monitor experience, and allowing users to focus their immediate attention on the most relevant information for them. For more information on configuring a default entry point, refer to the Configure an Entry Page or Dashboard for a Team section of the Sysdig Platform documentation.

                                                                        6.3 -

                                                                        Display Dashboard Specific Events

                                                                        Sysdig Monitor allows users to configure dashboards to display infrastructure events relevant to a dashboard’s panels within the panels themselves. This allows users an even more in-depth view of the status of their environment. To configure how events are displayed:

                                                                        1. On the Dashboard tab, select the relevant dashboard from the dashboard list.

                                                                        2. Click the Dashboard Settings (three dots) icon and select Events Display:

                                                                        3. Enable the Show Events slider to show events in the dashboard panels.

                                                                        4. Configure the available parameters, and click the Close button.

                                                                        OptionDescription
                                                                        FilterDefines specific events, or a scope of events, to display.
                                                                        ScopeDetermines whether the range of events displayed includes those for dashboard scope or team scope.
                                                                        SeverityDetermines whether only high severity events or all events are displayed.
                                                                        Event TypeDetermines what types of events to be displayed. The supported events types are alert, custom events, containers, or Kubernetes.
                                                                        StatusDetermines the state of events displayed. The supported status are Triggered, Resolved, Acknowledged, Un-acknowledged.

                                                                        6.4 -

                                                                        Sharing New Dashboards

                                                                        Dashboards can be shared internally among team members, with other teams, within the wider organization, or publicly, by configuring a public URL for the dashboard.

                                                                        As an owner of a dashboard, you can share the dashboard with any team and provide the Viewer or Collaborator access permission.

                                                                        Access Levels in Dashboard

                                                                        The RBAC-based permissions determine how users can interact with Dashboards. They establish what capabilities are allowed or denied for a user or a team. For more information on RBAC rules, see RBAC Rules for Dashboards.

                                                                        The table below summarizes the various ways a dashboard can be shared and effective permissions for users.

                                                                        Who can share/copyDashboard InstanceTeam/User who has accessCan ReadCan Edit
                                                                        Share with current TeamDashboard CreatorSame dashboard instanceCurrent team members onlyAll members of the teamEdit users of the team
                                                                        Share publicly as URLAny Edit User of the teamSame dashboard instanceAnyone with URL (does not have to by Sysdig user)AnyoneAnyone with URL (does not have to by Sysdig user) with Scope variables
                                                                        Copy to My TeamsAny Edit User of the teamDuplicate Copy of the dashboardCurrent team members onlyAll members of the teamEdit users of the team

                                                                        Share a Dashboard with Teams

                                                                        Dashboards can be shared across a user’s current team or a selected set of teams, allowing other team members to view the dashboard, as well as edit the panels if they have edit permissions within the team.

                                                                        If a dashboard has been shared with another team, a user within that team can then copy it to make it their own if they wish.

                                                                        To share a dashboard:

                                                                        1. Select the dashboard you want to share.

                                                                        2. Click the Dashboard Settings (three dots) icon and select Dashboard Settings.

                                                                        3. In the Dashboard Settings page, use the Shared With drop-down.

                                                                        4. Select one of the three options:

                                                                          • Not Shared: If selected, the specified Dashboard cannot be shared with a team or selected team the owner is a member of.

                                                                          • All Teams: If selected, the owners of the Dashboard can share with all the teams that they are part of.

                                                                          • Selected Teams: If selected, the owner of the Dashboard can share with a selected list of teams. You can select one of the available teams in the drop-down, and select member permission:

                                                                            • View Only: This permission allows members to view the Dashboard.

                                                                            • Collaborator: A collaborator can edit the Dashboard.

                                                                        Enable Public Sharing

                                                                        Dashboards can be shared outside of the internal team by using public URLs. This allows external users to review the dashboard metrics while restricting access to changing panels and configurations.

                                                                        The scope parameters, including scope variables, are included in the Dashboard URL. External users with a valid link can change the scope parameters without having to sign in. They can edit either on the UI or in the URL. The scope parameters are passed to the standard request header, consisting of a question mark, followed by the parameter name, an equal sign, and the parameter value. To edit a parameter in the URL, simply replace it with the desired one.

                                                                        1. Select the dashboard you want to share.

                                                                        2. Click the Dashboard Settings (three dots) icon and select Dashboard Settings.

                                                                        3. In the Dashboard Settings page, enable the Public Sharing slider.

                                                                          When enabled, the dashboard is visible with scope parameters to anyone with the link. If this setting is disabled, the link will no longer work, and the setting will need to be re-enabled and shared again in order for the dashboard to be accessed.

                                                                        4. Copy the public sharing URL for sharing.

                                                                        6.4.1 -

                                                                        RBAC Rules for Dashboards

                                                                        The table below summarizes the role-based permissions.

                                                                        Owner Permissions

                                                                        Roles

                                                                        Owner Permissions

                                                                        User Roles

                                                                        Administrator

                                                                        A user owning a dashboard will now have three different team sharing options:

                                                                        • Not Shared

                                                                        • Share with all the teams that the owner is part of

                                                                        • Share with a selected list of teams

                                                                        For the last two options, the owner can pick the type of access: Collaborator (with edit rights) or View only.

                                                                        Regular User (non-administrator user)

                                                                        Team Roles

                                                                        Advanced user

                                                                        Standard user

                                                                        Team manager

                                                                        View-only user

                                                                        Not applicable.

                                                                        Owner Permissions

                                                                        When a user decides to share a dashboard with a set of teams, they’ll only be able to pick teams that they are members of.

                                                                        The table below summarizes what you can do with a shared dashboard.

                                                                        User Permissions

                                                                        User Permissions

                                                                        View Only

                                                                        Collaborator

                                                                        User Role

                                                                        Administrator

                                                                        Edit

                                                                        An admin can still edit a shared dashboard even if it's shared in view-only mode.

                                                                        Edit

                                                                        Regular User (non-administrator user)

                                                                        View Only

                                                                        Team Role

                                                                        Advanced user

                                                                        Advanced user

                                                                        Team manager

                                                                        View-only user

                                                                        View Only

                                                                        User Permissions

                                                                        6.4.2 -

                                                                        Transfer Dashboard Ownership

                                                                        Dashboards have a single owner. Sysdig Monitor allows administrators and dashboard owners with administrator permissions to transfer the ownership of a dashboard within the UI.

                                                                        There are several reasons for assigning a new owner to dashboards.

                                                                        • The dashboard owners are no longer in control of the dashboard data.

                                                                        • Administrators require to update the dashboard settings or fix how data is displayed.

                                                                        General Guidelines

                                                                        • When a user is deleted, any shared dashboards they own or have created will be preserved by default.

                                                                        • The administrator can transfer only the dashboards that are shared by other users. Private dashboards cannot be seen and therefore cannot be transferred.

                                                                        • Transferring ownership can only happen one dashboard at a time.

                                                                        • When editing a user, the administrator can specify to transfer dashboards to a new owner.

                                                                        • Before changing the dashboard ownership,

                                                                          • It is a good practice to ensure that the new owner is part of the team the previous owner is part of. The administrator can preview the teams that will no longer be part of before confirming the transfer.

                                                                            The new owner need not be part of any teams the previous owner was part of. In this case, the dashboard will be transferred to the new owner but will no longer be shared with any team. The dashboard will become a private dashboard.

                                                                          • A shared dashboard will be visible only to the teams that the new owner is not part of.

                                                                        Transfer Ownership as an Admin

                                                                        1. Log in to the Monitor UI.

                                                                        2. Select Settings > Users.

                                                                        3. Select the user you want to change the ownership.

                                                                        4. Select one or multiple Dashboards that you want to assign a new owner.

                                                                        5. Click Transfer Ownership.

                                                                          The Transfer Dashboard Ownership page is displayed.

                                                                        6. Select a new user from the drop-down.

                                                                          If the user that you selected is not part of the teams that the Dashboard is shared with, you will see a prompt stating the Dashboard will be unshared with the teams that the new owner is not part of.

                                                                        7. If you are satisfied with the changes, click Transfer.

                                                                        Transfer Ownership as a User

                                                                        1. On the Dashboards tab, select the relevant dashboard from the left-hand panel.

                                                                        2. Click the Settings (three dots) icon for the dashboard.

                                                                        3. Select Transfer Ownership.

                                                                          The Transfer Dashboard Ownership page is displayed.

                                                                        4. Select a new user from the drop-down.

                                                                        5. If everything looks ok, click Transfer.

                                                                          The teams indicated with cross-out text are the ones that had access to the dashboard earlier and will lose access to it after the transfer.

                                                                          The dashboard will also be visible to all the teams that the new owner is part of. If you are not part of the teams that the new owner is a member of, you will no longer have the visibility to the dashboard.

                                                                        7 -

                                                                        Dashboard Templates

                                                                        Sysdig provides a number of pre-defined dashboards to assist users in monitoring their environments and applications. Dashboard templates are essentially immutable dashboards that can’t be edited, and the scope is fixed. They are useful as is to get a quick overview of infrastructure, but you can use them as a template and can copy them to customize.

                                                                        This section outlines the main dashboards that are available out-of-the-box.

                                                                        7.1 -

                                                                        Application Dashboards

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Elasticsearch

                                                                        This view lists eight important metrics for node and document counts, shards, indexing time and query latency.

                                                                        • Track the node count, as this can impact query times.

                                                                        HAProxy

                                                                        This view reports metrics for host CPU use and proxy throughput.

                                                                        Redis

                                                                        This view reports seven metrics for host resource usage and application performance.

                                                                        Cassandra By Node

                                                                        This view shows how every node in a Cassandra cluster is performing, by mixing key system metrics with Cassandra-specific metrics such as requests volume and compactions.

                                                                        • Use this view on a group containing the entire Cassandra cluster when you have already identified that there is a problem with a metric (using the "Cassandra Overview" view), and you need to see which node is causing the problem.

                                                                        • Spot issues such as imbalances between the size of data held in each node, nodes going down and generating a lot of hinted handoffs, or disk bottlenecks by looking at the pending compactions.

                                                                        Cassandra Overview

                                                                        This view shows how a Cassandra cluster is performing, by mixing key system metrics with Cassandra-specific metrics such as requests volume and compactions.

                                                                        • Use this view on a group containing the entire Cassandra cluster as a first starting point to troubleshoot the overall health of your database.

                                                                        • Inspect typical system metrics to make sure the cluster is not being overloaded

                                                                        • Correlate the information displayed with important advanced Cassandra metrics such as pending compactions or JVM metrics to identify critical problems.

                                                                        HTTP Top Requests

                                                                        This view details the top requested URLs to your web server, including the total number of requests, average and maximum times to service the requests, and the amount of traffic contained in the requests and responses.

                                                                        MongoDB

                                                                        This view shows how busy the MongoDB service is, which collections are in highest demand and which have the slowest performance.

                                                                        • Use to spot which collections may benefit from query and index performance tuning.

                                                                        HTTP

                                                                        This view provides a basic understanding of the health of your web server by showing the load being put on it and the server's ability to service requests in a timely manner.

                                                                        • Gauge the overall busyness of the server.

                                                                        • Identify correlations between the Top URLs and Slowest URLs panels to find opportunities to increase performance.

                                                                        MySQL/PostgreSQL

                                                                        This view shows the overall load and performance status of your SQL database transactions with metrics for the number of requests and how quickly they are handled.

                                                                        • Determine whether performance can be improved.

                                                                        MySQL/PostgreSQL Top

                                                                        This view shows the top SQL queries by displaying metrics for the number of queries received and the amount of traffic sent and received for the query.

                                                                        • Identify the most requested, highest traffic producing or slowest processing queries.

                                                                        7.2 -

                                                                        AWS CloudWatch Dashboards

                                                                        DashboardDescription
                                                                        ALB OverviewDisplays information such as unhealthy host count, response time, HTTP response count, active and new connection, and so on.
                                                                        DynamoDB OverviewProvides information such as user errors and consumed Read and Write capacity units.
                                                                        DynamoDB Overview By OperationShows the count of HTTP operations performed on the DynamoDB.
                                                                        EC2 OverviewDisplays CPU, disk, network operations in a selected window.
                                                                        ECS ProjectsProvides the resource count and usage percentage in each cluster.
                                                                        ECS OverviewHighlights the containers and services per host, request count, and highest resource consumption in containers.
                                                                        ECS ServicesDisplay information including container and request count per services and resource usage.
                                                                        ECS Task FamiliesDisplays container and request count per task family and resource usage.
                                                                        ElastiCache OverviewHighlights resource usage in ElastiCache.
                                                                        ELB OverviewHighlights resource usage in ELB.
                                                                        RDS OverviewHighlights resource usage in RDS.
                                                                        SQS OverviewDisplays information such as number of messages sent, received, deleted in SQS.

                                                                        7.3 -

                                                                        Capacity and Resource Management Dashboards

                                                                        DashboardDescription
                                                                        Available Resources CalculatorEnsure there is sufficient capacity in a cluster to deploy a new application.
                                                                        Cluster Capacity PlanningMonitor the capacity of Kubernetes clusters ensuring they’re correctly sized to support new applications when they’re deployed.
                                                                        Pod Scheduling TroubleshootingIf a pod cannot be scheduled due to insufficient resources, use this dashboard to identify where the resource bottleneck is.
                                                                        Pod Rightsizing & Capacity Optimization. Optimize your infrastructure and better control cluster spend by ensuring pods are sized correctly. Understand if you can free up resources by reducing memory and/or CPU requests.

                                                                        7.4 -

                                                                        Compliance & Security Dashboards

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Compliance (Docker)

                                                                        Provides an overview of the available compliance metrics for Docker.

                                                                        • Review the Docker configuration after running CIS Docker benchmark tests.

                                                                        Compliance (Kubernetes)

                                                                        Provides an overview of the available compliance metrics for Kubernetes

                                                                        • Review the Kubernetes Cluster configuration after running CIS Kubernetes benchmark tests.

                                                                        Sysdig Secure Summary

                                                                        The summary dashboard provides a complete overview of the Sysdig Secure environment, including the number of active agents, the number of defined policies and how many have been enabled, and summary policy event information.

                                                                        7.5 -

                                                                        Containers Dashboards

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Container Resource Usage

                                                                        Displays resource usage statistics, including CPU, file bytes, memory and network bytes, for containers running within the defined scope.

                                                                        • Monitor this view to identify which containers are using disproportionate amounts of resources.

                                                                        • Helpful in determining if an application should be moved to a more capable host.

                                                                        • Identify which file systems are filling up or being underutilized.

                                                                        Container File System Usage

                                                                        This table view shows directory mount points, file system devices, and capacity and usage information for the file systems mounted on the instance. When groups are selected, metrics are averages for similar filesystem mount points.

                                                                        Container CPU & Memory Limits

                                                                        Shows CPU and memory limits across the environment, and the percentages currently used.

                                                                        Container Network Traffic & Bandwidth

                                                                        Highlights network bytes usage, connection count, errors, and queue length.

                                                                        7.6 -

                                                                        Hosts Infrastructure Dashboards

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Host Resource Usage

                                                                        Displays resource usage statistics, including CPU, file bytes, memory and network bytes, for hosts running within the defined scope.

                                                                        • Use this view to identify when a host is being over or under utilized within a group of hosts with similar job functions.

                                                                        • Identify which file systems are filling up or being underutilized.

                                                                        Disk and File System

                                                                        This table view shows directory mount points, file system devices, and capacity and usage information for the file systems mounted on the instance. When groups are selected, metrics are averages for similar filesystem mount points.

                                                                        Remotely mounted file systems are not listed by default. To enable, add the remotefs = true entry to the /opt/draios/bin/dragent.properties file on each instance.

                                                                        Memory Usage

                                                                        Displays the memory and swap usage and page faults.

                                                                        Network Traffic & Bandwidth

                                                                        Provides an overview of network traffic in the host, including throughput, queue length, and errors

                                                                        Sysdig Agent Health and Status

                                                                        This view reports the number of Sysdig agents deployed in your environment and their versions.

                                                                        7.7 -

                                                                        Kubernetes Dashboards

                                                                        The Kubernetes * Health dashboards break down resource and performance metrics by various logical entities to allow for an in-depth analysis, and for critical issues to be identified and isolated. Each dashboard is built around the Golden Signals approach to monitoring: Latency, Traffic, Errors, and Saturation. Resource utilization metrics are oriented toward health and performance. These are aspects like CPU, memory, network, and storage usage by Kubernetes object. kube-state-metrics is about the status or count. Pairing kube-state-metrics with resource utilization metrics, each dashboard provides a comprehensive picture of what’s happening in your Kubernetes environment.

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Kubernetes Horizontal Pod Autoscaler

                                                                        Highlights minimum, maximum, current, and desired replicas.

                                                                        • Identify performance bottlenecks.

                                                                        • Identify whether there are enough available pods compared to the desired pods.

                                                                        • Use usage percentages over time to better estimate expansion capacity.

                                                                        • Locate logical entities that are consuming too many cluster resources, or that are rapidly trending upwards towards unsustainable levels.

                                                                        • Dive deeper into specific entities to identify the root cause of problems.

                                                                        • Use usage percentages over time to better estimate expansion capacity.

                                                                        For example:

                                                                        • A deployment with no available pods indicates that the corresponding app is not serving requests. Getting a dashboard on this condition means you can visualize the metrics and spring into action to find and resolve the issue quickly.

                                                                        • Dropping the number of pods available and remaining below the desired number indicate that your application performance is degraded or not running at the redundancy required. With these metrics represented on the dashboard, you get a quick glance of the severity of the impact on your app's user experience.

                                                                        • A lower number of replicas running during an extended period of time than the number of replicas desired indicates a symptom of entities not working properly, such as nodes or resources unavailability, Kubernetes or Docker Engine failure, broken Docker images, and so on. No replicas for a deployment object could potentially mean that the app is down.

                                                                        • A continuous loop of pod restart (CrashLoopBackOff) might be associated with missing dependencies or unmet requirements, or insufficient resources. In CrashLoopBackOff, pods never get into ready status and therefore are counted as unavailable and down.

                                                                        • Use these three dashboards to provide a high-level overview of all aspects of the Kubernetes environment's performance and resource saturation status.

                                                                        • Set high-level alerts to narrow down areas of concern, before moving to the more in-depth dashboards.

                                                                        • Quickly identify major performance issues within each type of entity.

                                                                        Kubernetes Resource Quota

                                                                        Provides an overview of resource limit and request, and the number of replication controllers, services, service ports, service load balancers, configMap, and secrets.

                                                                        Kubernetes Memory Allocation Optimization

                                                                        Highlights Memory allocation optimization.

                                                                        Kubernetes CPU Allocation Optimization

                                                                        Displays CPU utilization of your Kubernetes environment.

                                                                        Kubernetes Cluster Overview

                                                                        Provides an overview of your Kubernetes cluster.

                                                                        Kubernetes DaemonSet Overview

                                                                        Overview of DaemonSet objects.

                                                                        Kubernetes Deployment Overview

                                                                        Highlights whether each deployment has a sufficient number of available pods and resources, and indicates the number of pods running, desired, or have been updated.

                                                                        Kubernetes Job Overview

                                                                        Overview of all the jobs and the performance information.

                                                                        Kubernetes Namespace Overview

                                                                        Displays metrics such as resource requests and resource limits at the namespace level; identifies the performance of the Kubernetes entities such as pods, deployments, DaemonSet, Statefulset, and jobs, and compliance with replicaSets specs. Highlights the number of services, deployments, replicaSets, and jobs per namespace.

                                                                        Kubernetes Node Overview

                                                                        Highlights the number of nodes that are ready, unavailable, or out of disk; the number of nodes that are under the memory, disk, or network pressure; compares allocatable capacity with requested capacity on the node; provides the number of pod resources of a node that are available for scheduling and the available capacity to serve the pods running on the nodes.

                                                                        Kubernetes Pod Overview

                                                                        Helps identify potential bottlenecks by graphing the number of container restarts, the number of pods waiting to be scheduled, resource utilization of containers within each pod and available capacity to serve pod requests, the number of available pods compared to the desired pods, and the number of pods in available state and ready to serve requests.

                                                                        Kubernetes ReplicaSet Overview

                                                                        Provides details such as the number of pods per replicaSet, the desired number of pods per replicaSet, and pods per replicaSet that are in a ready state.

                                                                        Kubernetes StatefulSet Overview

                                                                        Overview of the StatefulSet objects in your environment.

                                                                        Kubernetes Cluster and Node Capacity

                                                                        Highlights a comprehensive overview of the performance of the hosts or nodes that form the Kubernetes cluster, including CPU, memory, and file system usage, and network traffic.

                                                                        Before analyzing the Dashboard, consider the following guidelines related to resource usage:

                                                                        • If Resource Limits is undefined for a container, Kubernetes does not default to a value.

                                                                        • if Resource Requests is unspecified for a container, Kubernetes defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. Limits do not default to any value.

                                                                        • If both Resource Limits and Resource Requests are not specified, no matter which value had been defaulted by Kubernetes, kube-state-metric (and hence Sysdig Monitor) reports zero. Therefore, only user-defined requested are reported by the kubernetes.pod.resourceRequests.memByte metric.

                                                                        • The memory used by a container (the value returned by memory.used.bytes) can be greater than the memory requested by a pod (the value returned by kubernetes.pod.resourceRequests.memByte). This is permissible in Kubernetes because Requests value determines the minimum amount of resources required.

                                                                        For these reasons, it can be deduced that

                                                                        • In some cases, the value of Used Resources will be more than that of Resource Requests and Resource Limits, and the value of Resource RequestS could be more than that of Resource Limit.

                                                                        • The value of kubernetes.pod.resourceRequests.memByte<=memory.used.bytes<=kubernetes.pod.resourceLimits.memByte

                                                                        Kubernetes Health Overview

                                                                        Provides a comprehensive overview of the performance of the entire Kubernetes environment, broken down by various logical entities and underlying resource availability and usage. This dashboard breaks down resource and performance kube-state-metrics by the logical Kubernetes entities, such as pods, namespaces, deployments, and replicaSets, containers, and so on.

                                                                        Kubernetes Service Health

                                                                        Displays the count, resource usage, performance, and limitations of services running in the Kuberenetes environment. The dashboard provides and overview of what resources each service is using, their response times, the container and request counts, and how the response times measure up against the resource utilization.

                                                                        Kubernetes Workloads CPU Usage and Allocation

                                                                        Displays resource utilization of your workloads. This dashboard helps you review the CPU usage of your workloads, making sure that the CPU is properly allocated in the Kubernetes environment. All the numbers in this dashboard are expressed in CPU cores.

                                                                        Kubernetes Workloads Memory Usage and Allocation

                                                                        Helps you review the memory usage of your workloads, making sure that the memory is properly allocated in the Kubernetes environment.

                                                                        Kubernetes Service Golden Signals

                                                                        Highlights the latency, traffic, errors, and saturation in your Kubernetes environment.

                                                                        7.8 -

                                                                        Marathon Dashboards

                                                                        DashboardDescription
                                                                        ApplicationsDisplays the container count and resource usage.
                                                                        OverviewHighlights the overall performance of marathon application. The dashboard provides container count, top resource-consuming containers and file system, request count by application, and so on.
                                                                        GroupsDisplays the container count and resource usage in each group.

                                                                        7.9 -

                                                                        Mesos Dashboards

                                                                        DashboardDescription
                                                                        FrameworksHighlights container count and resource consumption.
                                                                        OverviewProvides container count, top resource-consuming containers and file system, request count within defined scope.
                                                                        TasksShows the resource usage and performance of Mesos tasks.

                                                                        7.10 -

                                                                        Platform Application & Troubleshooting Dashboards

                                                                        DashboardDescription
                                                                        Application Status&OverviewUnderstand the status of applications (workloads) running in a cluster by monitoring performance, pod health, and resource usage.
                                                                        Pod Status&OverviewMonitor the health, resource usage, and network statistics for pods running as part of workloads.
                                                                        Container Resource Usage&Troubleshooting Understand the performance of the different containers running in pods across your infrastructure and identify any that are behaving anomalously.
                                                                        Node Status&OverviewMonitor the health, resource usage, and network statistics for nodes running in clusters.

                                                                        7.11 -

                                                                        Troubleshooting Dashboards

                                                                        Dashboard

                                                                        Description

                                                                        Use Cases

                                                                        Process Resource

                                                                        Highlights the resource consumption for processes (for example, httpd, java, and ntpd).

                                                                        • Identify the top consuming processes in an environment where the same process is spawned multiple times.

                                                                        • Monitor this view to identify which processes are using disproportionate amounts of resources.

                                                                        • Use to spot which collections may benefit from query and index performance tuning.

                                                                        • Identify the most requested, highest traffic producing or slowest processing queries.

                                                                        • Determine whether performance can be improved.

                                                                        MongoDB Troubleshooting

                                                                        Displays the performance of the MongoDB cluster. This view shows how busy the MongoDB service is, which collections are in highest demand and which have the slowest performance

                                                                        Network Connections Table

                                                                        Displays a full list of the environment’s local and remote endpoints, and all network traffic resource statistics relevant to those endpoints.

                                                                        SQL Troubleshooting

                                                                        Shows the top SQL queries by displaying metrics for the number of queries received and the amount of traffic sent and received for the query.

                                                                        Top Processes

                                                                        Lists the top processes running on the Kubernetes environment. Displays resource usage statistics, including CPU, file bytes, memory, and network bytes, for the top processes running within the defined scope.